Lines Matching refs:bay
3 * Driver for the media bay on the PowerBook 3400 and 2400.
32 #define MB_FCR32(bay, r) ((bay)->base + ((r) >> 2))
33 #define MB_FCR8(bay, r) (((volatile u8 __iomem *)((bay)->base)) + (r))
35 #define MB_IN32(bay,r) (in_le32(MB_FCR32(bay,r)))
36 #define MB_OUT32(bay,r,v) (out_le32(MB_FCR32(bay,r), (v)))
37 #define MB_BIS(bay,r,v) (MB_OUT32((bay), (r), MB_IN32((bay), r) | (v)))
38 #define MB_BIC(bay,r,v) (MB_OUT32((bay), (r), MB_IN32((bay), r) & ~(v)))
39 #define MB_IN8(bay,r) (in_8(MB_FCR8(bay,r)))
40 #define MB_OUT8(bay,r,v) (out_8(MB_FCR8(bay,r), (v)))
46 void (*init)(struct media_bay_info *bay);
47 u8 (*content)(struct media_bay_info *bay);
48 void (*power)(struct media_bay_info *bay, int on_off);
49 int (*setup_bus)(struct media_bay_info *bay, u8 device_id);
50 void (*un_reset)(struct media_bay_info *bay);
51 void (*un_reset_ide)(struct media_bay_info *bay);
81 * Consider the media-bay ID value stable if it is the same for
86 /* Wait after powering up the media bay this delay in ms
92 * Hold the media-bay reset signal true for this many ticks
111 * States of a media bay
119 mb_up, /* Media bay full */
130 * Functions for polling content of media bay
134 ohare_mb_content(struct media_bay_info *bay)
136 return (MB_IN32(bay, OHARE_MBCR) >> 12) & 7;
140 heathrow_mb_content(struct media_bay_info *bay)
142 return (MB_IN32(bay, HEATHROW_MBCR) >> 12) & 7;
146 keylargo_mb_content(struct media_bay_info *bay)
150 new_gpio = MB_IN8(bay, KL_GPIO_MEDIABAY_IRQ) & KEYLARGO_GPIO_INPUT_DATA;
152 bay->cached_gpio = new_gpio;
154 } else if (bay->cached_gpio != new_gpio) {
155 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
156 (void)MB_IN32(bay, KEYLARGO_MBCR);
158 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
159 (void)MB_IN32(bay, KEYLARGO_MBCR);
161 bay->cached_gpio = new_gpio;
163 return (MB_IN32(bay, KEYLARGO_MBCR) >> 4) & 7;
167 * Functions for powering up/down the bay, puts the bay device
172 ohare_mb_power(struct media_bay_info* bay, int on_off)
176 MB_BIC(bay, OHARE_FCR, OH_BAY_RESET_N);
177 MB_BIC(bay, OHARE_FCR, OH_BAY_POWER_N);
180 MB_BIC(bay, OHARE_FCR, OH_BAY_DEV_MASK);
181 MB_BIC(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
182 /* Cut power from bay, release reset line */
183 MB_BIS(bay, OHARE_FCR, OH_BAY_POWER_N);
184 MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
185 MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
187 MB_BIC(bay, OHARE_MBCR, 0x00000F00);
191 heathrow_mb_power(struct media_bay_info* bay, int on_off)
195 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
196 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
199 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_DEV_MASK);
200 MB_BIC(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
201 /* Cut power from bay, release reset line */
202 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
203 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
204 MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
206 MB_BIC(bay, HEATHROW_MBCR, 0x00000F00);
210 keylargo_mb_power(struct media_bay_info* bay, int on_off)
214 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
215 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
218 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
219 MB_BIC(bay, KEYLARGO_FCR1, KL1_EIDE0_ENABLE);
220 /* Cut power from bay, release reset line */
221 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
222 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
223 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
225 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
229 * Functions for configuring the media bay for a given type of device,
234 ohare_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
239 MB_BIS(bay, OHARE_FCR, OH_BAY_FLOPPY_ENABLE);
240 MB_BIS(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
243 MB_BIC(bay, OHARE_FCR, OH_IDE1_RESET_N);
244 MB_BIS(bay, OHARE_FCR, OH_BAY_IDE_ENABLE);
247 MB_BIS(bay, OHARE_FCR, OH_BAY_PCI_ENABLE);
254 heathrow_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
259 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_FLOPPY_ENABLE);
260 MB_BIS(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
263 MB_BIC(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
264 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_IDE_ENABLE);
267 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_PCI_ENABLE);
274 keylargo_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
278 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_IDE_ENABLE);
279 MB_BIC(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
280 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_ENABLE);
283 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_PCI_ENABLE);
286 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_SOUND_ENABLE);
297 ohare_mb_un_reset(struct media_bay_info* bay)
299 MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
302 static void keylargo_mb_init(struct media_bay_info *bay)
304 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
307 static void heathrow_mb_un_reset(struct media_bay_info* bay)
309 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
312 static void keylargo_mb_un_reset(struct media_bay_info* bay)
314 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
317 static void ohare_mb_un_reset_ide(struct media_bay_info* bay)
319 MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
322 static void heathrow_mb_un_reset_ide(struct media_bay_info* bay)
324 MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
327 static void keylargo_mb_un_reset_ide(struct media_bay_info* bay)
329 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
332 static inline void set_mb_power(struct media_bay_info* bay, int onoff)
334 /* Power up up and assert the bay reset line */
336 bay->ops->power(bay, 1);
337 bay->state = mb_powering_up;
338 pr_debug("mediabay%d: powering up\n", bay->index);
341 bay->ops->power(bay, 0);
342 bay->state = mb_powering_down;
343 pr_debug("mediabay%d: powering down\n", bay->index);
345 bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
348 static void poll_media_bay(struct media_bay_info* bay)
350 int id = bay->ops->content(bay);
361 if (id != bay->last_value) {
362 bay->last_value = id;
363 bay->value_count = 0;
366 if (id == bay->content_id)
369 bay->value_count += msecs_to_jiffies(MB_POLL_DELAY);
370 if (bay->value_count >= msecs_to_jiffies(MB_STABLE_DELAY)) {
375 if ((id != MB_NO) && (bay->content_id != MB_NO)) {
377 pr_debug("mediabay%d: forcing MB_NO\n", bay->index);
379 pr_debug("mediabay%d: switching to %d\n", bay->index, id);
380 set_mb_power(bay, id != MB_NO);
381 bay->content_id = id;
383 printk(KERN_INFO "mediabay%d: Bay is now empty\n", bay->index);
386 bay->index, mb_content_types[id]);
392 struct media_bay_info* bay;
399 * we may be called with the bay lock held. The resulting
403 bay = macio_get_drvdata(baydev);
404 if (bay == NULL)
406 id = bay->content_id;
407 if (bay->state != mb_up)
417 struct media_bay_info* bay;
421 bay = macio_get_drvdata(baydev);
422 if (bay == NULL)
424 mutex_lock(&bay->lock);
425 bay->user_lock = 1;
431 struct media_bay_info* bay;
435 bay = macio_get_drvdata(baydev);
436 if (bay == NULL)
438 if (bay->user_lock) {
439 bay->user_lock = 0;
440 mutex_unlock(&bay->lock);
447 struct media_bay_info* bay = data;
455 state = bay->state == mb_up ? bay->content_id : MB_NO;
467 struct media_bay_info* bay = &media_bays[i];
470 if (bay->state != mb_powering_down)
471 poll_media_bay(bay);
474 if (bay->timer != 0) {
475 bay->timer -= msecs_to_jiffies(MB_POLL_DELAY);
476 if (bay->timer > 0)
478 bay->timer = 0;
481 switch(bay->state) {
483 if (bay->ops->setup_bus(bay, bay->last_value) < 0) {
485 i, bay->content_id);
486 set_mb_power(bay, 0);
489 bay->timer = msecs_to_jiffies(MB_RESET_DELAY);
490 bay->state = mb_enabling_bay;
491 pr_debug("mediabay%d: enabling (kind:%d)\n", i, bay->content_id);
494 bay->ops->un_reset(bay);
495 bay->timer = msecs_to_jiffies(MB_SETUP_DELAY);
496 bay->state = mb_resetting;
497 pr_debug("mediabay%d: releasing bay reset (kind:%d)\n",
498 i, bay->content_id);
501 if (bay->content_id != MB_CD) {
502 pr_debug("mediabay%d: bay is up (kind:%d)\n", i,
503 bay->content_id);
504 bay->state = mb_up;
505 device_for_each_child(&bay->mdev->ofdev.dev,
506 bay, mb_broadcast_hotplug);
510 i, bay->content_id);
511 bay->ops->un_reset_ide(bay);
512 bay->timer = msecs_to_jiffies(MB_IDE_WAIT);
513 bay->state = mb_ide_resetting;
517 pr_debug("mediabay%d: bay is up (kind:%d)\n", i, bay->content_id);
518 bay->state = mb_up;
519 device_for_each_child(&bay->mdev->ofdev.dev,
520 bay, mb_broadcast_hotplug);
524 bay->state = mb_empty;
525 device_for_each_child(&bay->mdev->ofdev.dev,
526 bay, mb_broadcast_hotplug);
533 * This procedure runs as a kernel thread to poll the media bay
558 struct media_bay_info* bay;
568 if (macio_request_resources(mdev, "media-bay"))
570 /* Media bay registers are located at the beginning of the
582 bay = &media_bays[i];
583 bay->mdev = mdev;
584 bay->base = regbase;
585 bay->index = i;
586 bay->ops = match->data;
587 bay->sleeping = 0;
588 mutex_init(&bay->lock);
591 if (bay->ops->init)
592 bay->ops->init(bay);
594 printk(KERN_INFO "mediabay%d: Registered %s media-bay\n", i, bay->ops->name);
597 set_mb_power(bay, 0);
599 bay->content_id = MB_NO;
600 bay->last_value = bay->ops->content(bay);
601 bay->value_count = msecs_to_jiffies(MB_STABLE_DELAY);
602 bay->state = mb_empty;
605 macio_set_drvdata(mdev, bay);
609 kthread_run(media_bay_task, NULL, "media-bay");
617 struct media_bay_info *bay = macio_get_drvdata(mdev);
621 mutex_lock(&bay->lock);
622 bay->sleeping = 1;
623 set_mb_power(bay, 0);
624 mutex_unlock(&bay->lock);
633 struct media_bay_info *bay = macio_get_drvdata(mdev);
638 /* We re-enable the bay using it's previous content
643 mutex_lock(&bay->lock);
644 set_mb_power(bay, 0);
646 if (bay->ops->content(bay) != bay->content_id) {
647 printk("mediabay%d: Content changed during sleep...\n", bay->index);
648 mutex_unlock(&bay->lock);
651 set_mb_power(bay, 1);
652 bay->last_value = bay->content_id;
653 bay->value_count = msecs_to_jiffies(MB_STABLE_DELAY);
654 bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
657 media_bay_step(bay->index);
658 } while((bay->state != mb_empty) &&
659 (bay->state != mb_up));
660 bay->sleeping = 0;
661 mutex_unlock(&bay->lock);
698 * It seems that the bit for the media-bay interrupt in the IRQ_LEVEL
699 * register is always set when there is something in the media bay.
701 * handler to the media-bay interrupt, because it tends to go into
702 * an infinite loop calling the media bay interrupt handler.
703 * Therefore we do it all by polling the media bay once each tick.
709 .name = "media-bay",
710 .compatible = "keylargo-media-bay",
714 .name = "media-bay",
715 .compatible = "heathrow-media-bay",
719 .name = "media-bay",
720 .compatible = "ohare-media-bay",
729 .name = "media-bay",