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