?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / macintosh / mediabay.c
blobaa0719775e477f5031962296d39147d50a20ddc1
1 /*
2 * Driver for the media bay on the PowerBook 3400 and 2400.
3 *
4 * Copyright (C) 1998 Paul Mackerras.
5 *
6 * Various evolutions by Benjamin Herrenschmidt & Henry Worth
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13 #include <linux/config.h>
14 #include <linux/types.h>
15 #include <linux/errno.h>
16 #include <linux/kernel.h>
17 #include <linux/delay.h>
18 #include <linux/sched.h>
19 #include <linux/timer.h>
20 #include <linux/hdreg.h>
21 #include <linux/stddef.h>
22 #include <linux/init.h>
23 #include <linux/ide.h>
24 #include <asm/prom.h>
25 #include <asm/pgtable.h>
26 #include <asm/io.h>
27 #include <asm/machdep.h>
28 #include <asm/pmac_feature.h>
29 #include <asm/mediabay.h>
30 #include <asm/sections.h>
31 #include <asm/ohare.h>
32 #include <asm/heathrow.h>
33 #include <asm/keylargo.h>
34 #include <linux/adb.h>
35 #include <linux/pmu.h>
36
37
38 #define MB_DEBUG
39 #define MB_IGNORE_SIGNALS
40
41 #ifdef MB_DEBUG
42 #define MBDBG(fmt, arg...) printk(KERN_INFO fmt , ## arg)
43 #else
44 #define MBDBG(fmt, arg...) do { } while (0)
45 #endif
46
47 #define MB_FCR32(bay, r) ((bay)->base + ((r) >> 2))
48 #define MB_FCR8(bay, r) (((volatile u8*)((bay)->base)) + (r))
49
50 #define MB_IN32(bay,r) (in_le32(MB_FCR32(bay,r)))
51 #define MB_OUT32(bay,r,v) (out_le32(MB_FCR32(bay,r), (v)))
52 #define MB_BIS(bay,r,v) (MB_OUT32((bay), (r), MB_IN32((bay), r) | (v)))
53 #define MB_BIC(bay,r,v) (MB_OUT32((bay), (r), MB_IN32((bay), r) & ~(v)))
54 #define MB_IN8(bay,r) (in_8(MB_FCR8(bay,r)))
55 #define MB_OUT8(bay,r,v) (out_8(MB_FCR8(bay,r), (v)))
56
57 struct media_bay_info;
58
59 struct mb_ops {
60 char* name;
61 void (*init)(struct media_bay_info *bay);
62 u8 (*content)(struct media_bay_info *bay);
63 void (*power)(struct media_bay_info *bay, int on_off);
64 int (*setup_bus)(struct media_bay_info *bay, u8 device_id);
65 void (*un_reset)(struct media_bay_info *bay);
66 void (*un_reset_ide)(struct media_bay_info *bay);
67 };
68
69 struct media_bay_info {
70 volatile u32* base;
71 int content_id;
72 int state;
73 int last_value;
74 int value_count;
75 int timer;
76 struct macio_dev *mdev;
77 struct mb_ops* ops;
78 int index;
79 int cached_gpio;
80 int sleeping;
81 struct semaphore lock;
82 #ifdef CONFIG_BLK_DEV_IDE
83 unsigned long cd_base;
84 int cd_index;
85 int cd_irq;
86 int cd_retry;
87 #endif
88 };
89
90 #define MAX_BAYS 2
91
92 static struct media_bay_info media_bays[MAX_BAYS];
93 int media_bay_count = 0;
94
95 #ifdef CONFIG_BLK_DEV_IDE
96 /* check the busy bit in the media-bay ide interface
97 (assumes the media-bay contains an ide device) */
98 #define MB_IDE_READY(i) ((readb(media_bays[i].cd_base + 0x70) & 0x80) == 0)
99 #endif
100
101 /* Note: All delays are not in milliseconds and converted to HZ relative
102 * values by the macro below
103 */
104 #define MS_TO_HZ(ms) ((ms * HZ + 999) / 1000)
105
106 /*
107 * Wait that number of ms between each step in normal polling mode
108 */
109 #define MB_POLL_DELAY 25
110
111 /*
112 * Consider the media-bay ID value stable if it is the same for
113 * this number of milliseconds
114 */
115 #define MB_STABLE_DELAY 100
116
117 /* Wait after powering up the media bay this delay in ms
118 * timeout bumped for some powerbooks
119 */
120 #define MB_POWER_DELAY 200
121
122 /*
123 * Hold the media-bay reset signal true for this many ticks
124 * after a device is inserted before releasing it.
125 */
126 #define MB_RESET_DELAY 50
127
128 /*
129 * Wait this long after the reset signal is released and before doing
130 * further operations. After this delay, the IDE reset signal is released
131 * too for an IDE device
132 */
133 #define MB_SETUP_DELAY 100
134
135 /*
136 * Wait this many ticks after an IDE device (e.g. CD-ROM) is inserted
137 * (or until the device is ready) before waiting for busy bit to disappear
138 */
139 #define MB_IDE_WAIT 1000
140
141 /*
142 * Timeout waiting for busy bit of an IDE device to go down
143 */
144 #define MB_IDE_TIMEOUT 5000
145
146 /*
147 * Max retries of the full power up/down sequence for an IDE device
148 */
149 #define MAX_CD_RETRIES 3
150
151 /*
152 * States of a media bay
153 */
154 enum {
155 mb_empty = 0, /* Idle */
156 mb_powering_up, /* power bit set, waiting MB_POWER_DELAY */
157 mb_enabling_bay, /* enable bits set, waiting MB_RESET_DELAY */
158 mb_resetting, /* reset bit unset, waiting MB_SETUP_DELAY */
159 mb_ide_resetting, /* IDE reset bit unser, waiting MB_IDE_WAIT */
160 mb_ide_waiting, /* Waiting for BUSY bit to go away until MB_IDE_TIMEOUT */
161 mb_up, /* Media bay full */
162 mb_powering_down /* Powering down (avoid too fast down/up) */
163 };
164
165 #define MB_POWER_SOUND 0x08
166 #define MB_POWER_FLOPPY 0x04
167 #define MB_POWER_ATA 0x02
168 #define MB_POWER_PCI 0x01
169 #define MB_POWER_OFF 0x00
170
171 /*
172 * Functions for polling content of media bay
173 */
174
175 static u8 __pmac
176 ohare_mb_content(struct media_bay_info *bay)
177 {
178 return (MB_IN32(bay, OHARE_MBCR) >> 12) & 7;
179 }
180
181 static u8 __pmac
182 heathrow_mb_content(struct media_bay_info *bay)
183 {
184 return (MB_IN32(bay, HEATHROW_MBCR) >> 12) & 7;
185 }
186
187 static u8 __pmac
188 keylargo_mb_content(struct media_bay_info *bay)
189 {
190 int new_gpio;
191
192 new_gpio = MB_IN8(bay, KL_GPIO_MEDIABAY_IRQ) & KEYLARGO_GPIO_INPUT_DATA;
193 if (new_gpio) {
194 bay->cached_gpio = new_gpio;
195 return MB_NO;
196 } else if (bay->cached_gpio != new_gpio) {
197 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
198 (void)MB_IN32(bay, KEYLARGO_MBCR);
199 udelay(5);
200 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
201 (void)MB_IN32(bay, KEYLARGO_MBCR);
202 udelay(5);
203 bay->cached_gpio = new_gpio;
204 }
205 return (MB_IN32(bay, KEYLARGO_MBCR) >> 4) & 7;
206 }
207
208 /*
209 * Functions for powering up/down the bay, puts the bay device
210 * into reset state as well
211 */
212
213 static void __pmac
214 ohare_mb_power(struct media_bay_info* bay, int on_off)
215 {
216 if (on_off) {
217 /* Power up device, assert it's reset line */
218 MB_BIC(bay, OHARE_FCR, OH_BAY_RESET_N);
219 MB_BIC(bay, OHARE_FCR, OH_BAY_POWER_N);
220 } else {
221 /* Disable all devices */
222 MB_BIC(bay, OHARE_FCR, OH_BAY_DEV_MASK);
223 MB_BIC(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
224 /* Cut power from bay, release reset line */
225 MB_BIS(bay, OHARE_FCR, OH_BAY_POWER_N);
226 MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
227 MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
228 }
229 MB_BIC(bay, OHARE_MBCR, 0x00000F00);
230 }
231
232 static void __pmac
233 heathrow_mb_power(struct media_bay_info* bay, int on_off)
234 {
235 if (on_off) {
236 /* Power up device, assert it's reset line */
237 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
238 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
239 } else {
240 /* Disable all devices */
241 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_DEV_MASK);
242 MB_BIC(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
243 /* Cut power from bay, release reset line */
244 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
245 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
246 MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
247 }
248 MB_BIC(bay, HEATHROW_MBCR, 0x00000F00);
249 }
250
251 static void __pmac
252 keylargo_mb_power(struct media_bay_info* bay, int on_off)
253 {
254 if (on_off) {
255 /* Power up device, assert it's reset line */
256 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
257 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
258 } else {
259 /* Disable all devices */
260 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
261 MB_BIC(bay, KEYLARGO_FCR1, KL1_EIDE0_ENABLE);
262 /* Cut power from bay, release reset line */
263 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
264 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
265 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
266 }
267 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
268 }
269
270 /*
271 * Functions for configuring the media bay for a given type of device,
272 * enable the related busses
273 */
274
275 static int __pmac
276 ohare_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
277 {
278 switch(device_id) {
279 case MB_FD:
280 case MB_FD1:
281 MB_BIS(bay, OHARE_FCR, OH_BAY_FLOPPY_ENABLE);
282 MB_BIS(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
283 return 0;
284 case MB_CD:
285 MB_BIC(bay, OHARE_FCR, OH_IDE1_RESET_N);
286 MB_BIS(bay, OHARE_FCR, OH_BAY_IDE_ENABLE);
287 return 0;
288 case MB_PCI:
289 MB_BIS(bay, OHARE_FCR, OH_BAY_PCI_ENABLE);
290 return 0;
291 }
292 return -ENODEV;
293 }
294
295 static int __pmac
296 heathrow_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
297 {
298 switch(device_id) {
299 case MB_FD:
300 case MB_FD1:
301 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_FLOPPY_ENABLE);
302 MB_BIS(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
303 return 0;
304 case MB_CD:
305 MB_BIC(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
306 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_IDE_ENABLE);
307 return 0;
308 case MB_PCI:
309 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_PCI_ENABLE);
310 return 0;
311 }
312 return -ENODEV;
313 }
314
315 static int __pmac
316 keylargo_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
317 {
318 switch(device_id) {
319 case MB_CD:
320 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_IDE_ENABLE);
321 MB_BIC(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
322 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_ENABLE);
323 return 0;
324 case MB_PCI:
325 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_PCI_ENABLE);
326 return 0;
327 case MB_SOUND:
328 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_SOUND_ENABLE);
329 return 0;
330 }
331 return -ENODEV;
332 }
333
334 /*
335 * Functions for tweaking resets
336 */
337
338 static void __pmac
339 ohare_mb_un_reset(struct media_bay_info* bay)
340 {
341 MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
342 }
343
344 static void __pmac keylargo_mb_init(struct media_bay_info *bay)
345 {
346 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
347 }
348
349 static void __pmac heathrow_mb_un_reset(struct media_bay_info* bay)
350 {
351 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
352 }
353
354 static void __pmac keylargo_mb_un_reset(struct media_bay_info* bay)
355 {
356 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
357 }
358
359 static void __pmac ohare_mb_un_reset_ide(struct media_bay_info* bay)
360 {
361 MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
362 }
363
364 static void __pmac heathrow_mb_un_reset_ide(struct media_bay_info* bay)
365 {
366 MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
367 }
368
369 static void __pmac keylargo_mb_un_reset_ide(struct media_bay_info* bay)
370 {
371 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
372 }
373
374 static inline void __pmac set_mb_power(struct media_bay_info* bay, int onoff)
375 {
376 /* Power up up and assert the bay reset line */
377 if (onoff) {
378 bay->ops->power(bay, 1);
379 bay->state = mb_powering_up;
380 MBDBG("mediabay%d: powering up\n", bay->index);
381 } else {
382 /* Make sure everything is powered down & disabled */
383 bay->ops->power(bay, 0);
384 bay->state = mb_powering_down;
385 MBDBG("mediabay%d: powering down\n", bay->index);
386 }
387 bay->timer = MS_TO_HZ(MB_POWER_DELAY);
388 }
389
390 static void __pmac poll_media_bay(struct media_bay_info* bay)
391 {
392 int id = bay->ops->content(bay);
393
394 if (id == bay->last_value) {
395 if (id != bay->content_id) {
396 bay->value_count += MS_TO_HZ(MB_POLL_DELAY);
397 if (bay->value_count >= MS_TO_HZ(MB_STABLE_DELAY)) {
398 /* If the device type changes without going thru
399 * "MB_NO", we force a pass by "MB_NO" to make sure
400 * things are properly reset
401 */
402 if ((id != MB_NO) && (bay->content_id != MB_NO)) {
403 id = MB_NO;
404 MBDBG("mediabay%d: forcing MB_NO\n", bay->index);
405 }
406 MBDBG("mediabay%d: switching to %d\n", bay->index, id);
407 set_mb_power(bay, id != MB_NO);
408 bay->content_id = id;
409 if (id == MB_NO) {
410 #ifdef CONFIG_BLK_DEV_IDE
411 bay->cd_retry = 0;
412 #endif
413 printk(KERN_INFO "media bay %d is empty\n", bay->index);
414 }
415 }
416 }
417 } else {
418 bay->last_value = id;
419 bay->value_count = 0;
420 }
421 }
422
423 int __pmac check_media_bay(struct device_node *which_bay, int what)
424 {
425 #ifdef CONFIG_BLK_DEV_IDE
426 int i;
427
428 for (i=0; i<media_bay_count; i++)
429 if (media_bays[i].mdev && which_bay == media_bays[i].mdev->ofdev.node) {
430 if ((what == media_bays[i].content_id) && media_bays[i].state == mb_up)
431 return 0;
432 media_bays[i].cd_index = -1;
433 return -EINVAL;
434 }
435 #endif /* CONFIG_BLK_DEV_IDE */
436 return -ENODEV;
437 }
438 EXPORT_SYMBOL(check_media_bay);
439
440 int __pmac check_media_bay_by_base(unsigned long base, int what)
441 {
442 #ifdef CONFIG_BLK_DEV_IDE
443 int i;
444
445 for (i=0; i<media_bay_count; i++)
446 if (media_bays[i].mdev && base == media_bays[i].cd_base) {
447 if ((what == media_bays[i].content_id) && media_bays[i].state == mb_up)
448 return 0;
449 media_bays[i].cd_index = -1;
450 return -EINVAL;
451 }
452 #endif
453
454 return -ENODEV;
455 }
456
457 int __pmac media_bay_set_ide_infos(struct device_node* which_bay, unsigned long base,
458 int irq, int index)
459 {
460 #ifdef CONFIG_BLK_DEV_IDE
461 int i;
462
463 for (i=0; i<media_bay_count; i++) {
464 struct media_bay_info* bay = &media_bays[i];
465
466 if (bay->mdev && which_bay == bay->mdev->ofdev.node) {
467 int timeout = 5000;
468
469 down(&bay->lock);
470
471 bay->cd_base = base;
472 bay->cd_irq = irq;
473
474 if ((MB_CD != bay->content_id) || bay->state != mb_up) {
475 up(&bay->lock);
476 return 0;
477 }
478 printk(KERN_DEBUG "Registered ide%d for media bay %d\n", index, i);
479 do {
480 if (MB_IDE_READY(i)) {
481 bay->cd_index = index;
482 up(&bay->lock);
483 return 0;
484 }
485 mdelay(1);
486 } while(--timeout);
487 printk(KERN_DEBUG "Timeount waiting IDE in bay %d\n", i);
488 up(&bay->lock);
489 return -ENODEV;
490 }
491 }
492 #endif /* CONFIG_BLK_DEV_IDE */
493
494 return -ENODEV;
495 }
496
497 static void __pmac media_bay_step(int i)
498 {
499 struct media_bay_info* bay = &media_bays[i];
500
501 /* We don't poll when powering down */
502 if (bay->state != mb_powering_down)
503 poll_media_bay(bay);
504
505 /* If timer expired or polling IDE busy, run state machine */
506 if ((bay->state != mb_ide_waiting) && (bay->timer != 0)) {
507 bay->timer -= MS_TO_HZ(MB_POLL_DELAY);
508 if (bay->timer > 0)
509 return;
510 bay->timer = 0;
511 }
512
513 switch(bay->state) {
514 case mb_powering_up:
515 if (bay->ops->setup_bus(bay, bay->last_value) < 0) {
516 MBDBG("mediabay%d: device not supported (kind:%d)\n", i, bay->content_id);
517 set_mb_power(bay, 0);
518 break;
519 }
520 bay->timer = MS_TO_HZ(MB_RESET_DELAY);
521 bay->state = mb_enabling_bay;
522 MBDBG("mediabay%d: enabling (kind:%d)\n", i, bay->content_id);
523 break;
524 case mb_enabling_bay:
525 bay->ops->un_reset(bay);
526 bay->timer = MS_TO_HZ(MB_SETUP_DELAY);
527 bay->state = mb_resetting;
528 MBDBG("mediabay%d: waiting reset (kind:%d)\n", i, bay->content_id);
529 break;
530
531 case mb_resetting:
532 if (bay->content_id != MB_CD) {
533 MBDBG("mediabay%d: bay is up (kind:%d)\n", i, bay->content_id);
534 bay->state = mb_up;
535 break;
536 }
537 #ifdef CONFIG_BLK_DEV_IDE
538 MBDBG("mediabay%d: waiting IDE reset (kind:%d)\n", i, bay->content_id);
539 bay->ops->un_reset_ide(bay);
540 bay->timer = MS_TO_HZ(MB_IDE_WAIT);
541 bay->state = mb_ide_resetting;
542 #else
543 printk(KERN_DEBUG "media-bay %d is ide (not compiled in kernel)\n", i);
544 set_mb_power(bay, 0);
545 #endif /* CONFIG_BLK_DEV_IDE */
546 break;
547
548 #ifdef CONFIG_BLK_DEV_IDE
549 case mb_ide_resetting:
550 bay->timer = MS_TO_HZ(MB_IDE_TIMEOUT);
551 bay->state = mb_ide_waiting;
552 MBDBG("mediabay%d: waiting IDE ready (kind:%d)\n", i, bay->content_id);
553 break;
554
555 case mb_ide_waiting:
556 if (bay->cd_base == 0) {
557 bay->timer = 0;
558 bay->state = mb_up;
559 MBDBG("mediabay%d: up before IDE init\n", i);
560 break;
561 } else if (MB_IDE_READY(i)) {
562 bay->timer = 0;
563 bay->state = mb_up;
564 if (bay->cd_index < 0) {
565 hw_regs_t hw;
566
567 printk("mediabay %d, registering IDE...\n", i);
568 pmu_suspend();
569 ide_init_hwif_ports(&hw, (unsigned long) bay->cd_base, (unsigned long) 0, NULL);
570 hw.irq = bay->cd_irq;
571 hw.chipset = ide_pmac;
572 bay->cd_index = ide_register_hw(&hw, NULL);
573 pmu_resume();
574 }
575 if (bay->cd_index == -1) {
576 /* We eventually do a retry */
577 bay->cd_retry++;
578 printk("IDE register error\n");
579 set_mb_power(bay, 0);
580 } else {
581 printk(KERN_DEBUG "media-bay %d is ide%d\n", i, bay->cd_index);
582 MBDBG("mediabay %d IDE ready\n", i);
583 }
584 break;
585 } else if (bay->timer > 0)
586 bay->timer -= MS_TO_HZ(MB_POLL_DELAY);
587 if (bay->timer <= 0) {
588 printk("\nIDE Timeout in bay %d !, IDE state is: 0x%02x\n",
589 i, readb(bay->cd_base + 0x70));
590 MBDBG("mediabay%d: nIDE Timeout !\n", i);
591 set_mb_power(bay, 0);
592 bay->timer = 0;
593 }
594 break;
595 #endif /* CONFIG_BLK_DEV_IDE */
596
597 case mb_powering_down:
598 bay->state = mb_empty;
599 #ifdef CONFIG_BLK_DEV_IDE
600 if (bay->cd_index >= 0) {
601 printk(KERN_DEBUG "Unregistering mb %d ide, index:%d\n", i,
602 bay->cd_index);
603 ide_unregister(bay->cd_index);
604 bay->cd_index = -1;
605 }
606 if (bay->cd_retry) {
607 if (bay->cd_retry > MAX_CD_RETRIES) {
608 /* Should add an error sound (sort of beep in dmasound) */
609 printk("\nmedia-bay %d, IDE device badly inserted or unrecognised\n", i);
610 } else {
611 /* Force a new power down/up sequence */
612 bay->content_id = MB_NO;
613 }
614 }
615 #endif /* CONFIG_BLK_DEV_IDE */
616 MBDBG("mediabay%d: end of power down\n", i);
617 break;
618 }
619 }
620
621 /*
622 * This procedure runs as a kernel thread to poll the media bay
623 * once each tick and register and unregister the IDE interface
624 * with the IDE driver. It needs to be a thread because
625 * ide_register can't be called from interrupt context.
626 */
627 static int __pmac media_bay_task(void *x)
628 {
629 int i;
630
631 strcpy(current->comm, "media-bay");
632 #ifdef MB_IGNORE_SIGNALS
633 sigfillset(&current->blocked);
634 #endif
635
636 for (;;) {
637 for (i = 0; i < media_bay_count; ++i) {
638 down(&media_bays[i].lock);
639 if (!media_bays[i].sleeping)
640 media_bay_step(i);
641 up(&media_bays[i].lock);
642 }
643
644 current->state = TASK_INTERRUPTIBLE;
645 schedule_timeout(MS_TO_HZ(MB_POLL_DELAY));
646 if (signal_pending(current))
647 return 0;
648 }
649 }
650
651 static int __devinit media_bay_attach(struct macio_dev *mdev, const struct of_match *match)
652 {
653 struct media_bay_info* bay;
654 volatile u32 *regbase;
655 struct device_node *ofnode;
656 int i;
657
658 ofnode = mdev->ofdev.node;
659
660 if (macio_resource_count(mdev) < 1)
661 return -ENODEV;
662 if (macio_request_resources(mdev, "media-bay"))
663 return -EBUSY;
664 /* Media bay registers are located at the beginning of the
665 * mac-io chip, we get the parent address for now (hrm...)
666 */
667 regbase = (volatile u32 *)ioremap(ofnode->parent->addrs[0].address, 0x100);
668 if (regbase == NULL) {
669 macio_release_resources(mdev);
670 return -ENOMEM;
671 }
672
673 i = media_bay_count++;
674 bay = &media_bays[i];
675 bay->mdev = mdev;
676 bay->base = regbase;
677 bay->index = i;
678 bay->ops = match->data;
679 bay->sleeping = 0;
680 init_MUTEX(&bay->lock);
681
682 /* Init HW probing */
683 if (bay->ops->init)
684 bay->ops->init(bay);
685
686 printk(KERN_INFO "mediabay%d: Registered %s media-bay\n", i, bay->ops->name);
687
688 /* Force an immediate detect */
689 set_mb_power(bay, 0);
690 msleep(MB_POWER_DELAY);
691 bay->content_id = MB_NO;
692 bay->last_value = bay->ops->content(bay);
693 bay->value_count = MS_TO_HZ(MB_STABLE_DELAY);
694 bay->state = mb_empty;
695 do {
696 msleep(MB_POLL_DELAY);
697 media_bay_step(i);
698 } while((bay->state != mb_empty) &&
699 (bay->state != mb_up));
700
701 /* Mark us ready by filling our mdev data */
702 macio_set_drvdata(mdev, bay);
703
704 /* Startup kernel thread */
705 if (i == 0)
706 kernel_thread(media_bay_task, NULL, CLONE_KERNEL);
707
708 return 0;
709
710 }
711
712 static int __pmac media_bay_suspend(struct macio_dev *mdev, u32 state)
713 {
714 struct media_bay_info *bay = macio_get_drvdata(mdev);
715
716 if (state != mdev->ofdev.dev.power_state && state >= 2) {
717 down(&bay->lock);
718 bay->sleeping = 1;
719 set_mb_power(bay, 0);
720 up(&bay->lock);
721 msleep(MB_POLL_DELAY);
722 mdev->ofdev.dev.power_state = state;
723 }
724 return 0;
725 }
726
727 static int __pmac media_bay_resume(struct macio_dev *mdev)
728 {
729 struct media_bay_info *bay = macio_get_drvdata(mdev);
730
731 if (mdev->ofdev.dev.power_state != 0) {
732 mdev->ofdev.dev.power_state = 0;
733
734 /* We re-enable the bay using it's previous content
735 only if it did not change. Note those bozo timings,
736 they seem to help the 3400 get it right.
737 */
738 /* Force MB power to 0 */
739 down(&bay->lock);
740 set_mb_power(bay, 0);
741 msleep(MB_POWER_DELAY);
742 if (bay->ops->content(bay) != bay->content_id) {
743 printk("mediabay%d: content changed during sleep...\n", bay->index);
744 up(&bay->lock);
745 return 0;
746 }
747 set_mb_power(bay, 1);
748 bay->last_value = bay->content_id;
749 bay->value_count = MS_TO_HZ(MB_STABLE_DELAY);
750 bay->timer = MS_TO_HZ(MB_POWER_DELAY);
751 #ifdef CONFIG_BLK_DEV_IDE
752 bay->cd_retry = 0;
753 #endif
754 do {
755 msleep(MB_POLL_DELAY);
756 media_bay_step(bay->index);
757 } while((bay->state != mb_empty) &&
758 (bay->state != mb_up));
759 bay->sleeping = 0;
760 up(&bay->lock);
761 }
762 return 0;
763 }
764
765
766 /* Definitions of "ops" structures.
767 */
768 static struct mb_ops ohare_mb_ops __pmacdata = {
769 .name = "Ohare",
770 .content = ohare_mb_content,
771 .power = ohare_mb_power,
772 .setup_bus = ohare_mb_setup_bus,
773 .un_reset = ohare_mb_un_reset,
774 .un_reset_ide = ohare_mb_un_reset_ide,
775 };
776
777 static struct mb_ops heathrow_mb_ops __pmacdata = {
778 .name = "Heathrow",
779 .content = heathrow_mb_content,
780 .power = heathrow_mb_power,
781 .setup_bus = heathrow_mb_setup_bus,
782 .un_reset = heathrow_mb_un_reset,
783 .un_reset_ide = heathrow_mb_un_reset_ide,
784 };
785
786 static struct mb_ops keylargo_mb_ops __pmacdata = {
787 .name = "KeyLargo",
788 .init = keylargo_mb_init,
789 .content = keylargo_mb_content,
790 .power = keylargo_mb_power,
791 .setup_bus = keylargo_mb_setup_bus,
792 .un_reset = keylargo_mb_un_reset,
793 .un_reset_ide = keylargo_mb_un_reset_ide,
794 };
795
796 /*
797 * It seems that the bit for the media-bay interrupt in the IRQ_LEVEL
798 * register is always set when there is something in the media bay.
799 * This causes problems for the interrupt code if we attach an interrupt
800 * handler to the media-bay interrupt, because it tends to go into
801 * an infinite loop calling the media bay interrupt handler.
802 * Therefore we do it all by polling the media bay once each tick.
803 */
804
805 static struct of_match media_bay_match[] =
806 {
807 {
808 .name = "media-bay",
809 .type = OF_ANY_MATCH,
810 .compatible = "keylargo-media-bay",
811 .data = &keylargo_mb_ops,
812 },
813 {
814 .name = "media-bay",
815 .type = OF_ANY_MATCH,
816 .compatible = "heathrow-media-bay",
817 .data = &heathrow_mb_ops,
818 },
819 {
820 .name = "media-bay",
821 .type = OF_ANY_MATCH,
822 .compatible = "ohare-media-bay",
823 .data = &ohare_mb_ops,
824 },
825 {},
826 };
827
828 static struct macio_driver media_bay_driver =
829 {
830 .name = "media-bay",
831 .match_table = media_bay_match,
832 .probe = media_bay_attach,
833 .suspend = media_bay_suspend,
834 .resume = media_bay_resume
835 };
836
837 static int __init media_bay_init(void)
838 {
839 int i;
840
841 for (i=0; i<MAX_BAYS; i++) {
842 memset((char *)&media_bays[i], 0, sizeof(struct media_bay_info));
843 media_bays[i].content_id = -1;
844 #ifdef CONFIG_BLK_DEV_IDE
845 media_bays[i].cd_index = -1;
846 #endif
847 }
848 if (_machine != _MACH_Pmac)
849 return -ENODEV;
850
851 macio_register_driver(&media_bay_driver);
852
853 return 0;
854 }
855
856 device_initcall(media_bay_init);
MOXA 2.6.9 from sdlinux-moxaart.tgz