Lines Matching defs:bay
2 * Driver for the media bay on the PowerBook 3400 and 2400.
36 #define MB_FCR32(bay, r) ((bay)->base + ((r) >> 2))
37 #define MB_FCR8(bay, r) (((volatile u8 __iomem *)((bay)->base)) + (r))
39 #define MB_IN32(bay,r) (in_le32(MB_FCR32(bay,r)))
40 #define MB_OUT32(bay,r,v) (out_le32(MB_FCR32(bay,r), (v)))
41 #define MB_BIS(bay,r,v) (MB_OUT32((bay), (r), MB_IN32((bay), r) | (v)))
42 #define MB_BIC(bay,r,v) (MB_OUT32((bay), (r), MB_IN32((bay), r) & ~(v)))
43 #define MB_IN8(bay,r) (in_8(MB_FCR8(bay,r)))
44 #define MB_OUT8(bay,r,v) (out_8(MB_FCR8(bay,r), (v)))
50 void (*init)(struct media_bay_info *bay);
51 u8 (*content)(struct media_bay_info *bay);
52 void (*power)(struct media_bay_info *bay, int on_off);
53 int (*setup_bus)(struct media_bay_info *bay, u8 device_id);
54 void (*un_reset)(struct media_bay_info *bay);
55 void (*un_reset_ide)(struct media_bay_info *bay);
85 * Consider the media-bay ID value stable if it is the same for
90 /* Wait after powering up the media bay this delay in ms
96 * Hold the media-bay reset signal true for this many ticks
115 * States of a media bay
123 mb_up, /* Media bay full */
134 * Functions for polling content of media bay
138 ohare_mb_content(struct media_bay_info *bay)
140 return (MB_IN32(bay, OHARE_MBCR) >> 12) & 7;
144 heathrow_mb_content(struct media_bay_info *bay)
146 return (MB_IN32(bay, HEATHROW_MBCR) >> 12) & 7;
150 keylargo_mb_content(struct media_bay_info *bay)
154 new_gpio = MB_IN8(bay, KL_GPIO_MEDIABAY_IRQ) & KEYLARGO_GPIO_INPUT_DATA;
156 bay->cached_gpio = new_gpio;
158 } else if (bay->cached_gpio != new_gpio) {
159 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
160 (void)MB_IN32(bay, KEYLARGO_MBCR);
162 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
163 (void)MB_IN32(bay, KEYLARGO_MBCR);
165 bay->cached_gpio = new_gpio;
167 return (MB_IN32(bay, KEYLARGO_MBCR) >> 4) & 7;
171 * Functions for powering up/down the bay, puts the bay device
176 ohare_mb_power(struct media_bay_info* bay, int on_off)
180 MB_BIC(bay, OHARE_FCR, OH_BAY_RESET_N);
181 MB_BIC(bay, OHARE_FCR, OH_BAY_POWER_N);
184 MB_BIC(bay, OHARE_FCR, OH_BAY_DEV_MASK);
185 MB_BIC(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
186 /* Cut power from bay, release reset line */
187 MB_BIS(bay, OHARE_FCR, OH_BAY_POWER_N);
188 MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
189 MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
191 MB_BIC(bay, OHARE_MBCR, 0x00000F00);
195 heathrow_mb_power(struct media_bay_info* bay, int on_off)
199 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
200 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
203 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_DEV_MASK);
204 MB_BIC(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
205 /* Cut power from bay, release reset line */
206 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
207 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
208 MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
210 MB_BIC(bay, HEATHROW_MBCR, 0x00000F00);
214 keylargo_mb_power(struct media_bay_info* bay, int on_off)
218 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
219 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
222 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
223 MB_BIC(bay, KEYLARGO_FCR1, KL1_EIDE0_ENABLE);
224 /* Cut power from bay, release reset line */
225 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
226 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
227 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
229 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
233 * Functions for configuring the media bay for a given type of device,
238 ohare_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
243 MB_BIS(bay, OHARE_FCR, OH_BAY_FLOPPY_ENABLE);
244 MB_BIS(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
247 MB_BIC(bay, OHARE_FCR, OH_IDE1_RESET_N);
248 MB_BIS(bay, OHARE_FCR, OH_BAY_IDE_ENABLE);
251 MB_BIS(bay, OHARE_FCR, OH_BAY_PCI_ENABLE);
258 heathrow_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
263 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_FLOPPY_ENABLE);
264 MB_BIS(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
267 MB_BIC(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
268 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_IDE_ENABLE);
271 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_PCI_ENABLE);
278 keylargo_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
282 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_IDE_ENABLE);
283 MB_BIC(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
284 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_ENABLE);
287 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_PCI_ENABLE);
290 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_SOUND_ENABLE);
301 ohare_mb_un_reset(struct media_bay_info* bay)
303 MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
306 static void keylargo_mb_init(struct media_bay_info *bay)
308 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
311 static void heathrow_mb_un_reset(struct media_bay_info* bay)
313 MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
316 static void keylargo_mb_un_reset(struct media_bay_info* bay)
318 MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
321 static void ohare_mb_un_reset_ide(struct media_bay_info* bay)
323 MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
326 static void heathrow_mb_un_reset_ide(struct media_bay_info* bay)
328 MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
331 static void keylargo_mb_un_reset_ide(struct media_bay_info* bay)
333 MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
336 static inline void set_mb_power(struct media_bay_info* bay, int onoff)
338 /* Power up up and assert the bay reset line */
340 bay->ops->power(bay, 1);
341 bay->state = mb_powering_up;
342 pr_debug("mediabay%d: powering up\n", bay->index);
345 bay->ops->power(bay, 0);
346 bay->state = mb_powering_down;
347 pr_debug("mediabay%d: powering down\n", bay->index);
349 bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
352 static void poll_media_bay(struct media_bay_info* bay)
354 int id = bay->ops->content(bay);
365 if (id != bay->last_value) {
366 bay->last_value = id;
367 bay->value_count = 0;
370 if (id == bay->content_id)
373 bay->value_count += msecs_to_jiffies(MB_POLL_DELAY);
374 if (bay->value_count >= msecs_to_jiffies(MB_STABLE_DELAY)) {
379 if ((id != MB_NO) && (bay->content_id != MB_NO)) {
381 pr_debug("mediabay%d: forcing MB_NO\n", bay->index);
383 pr_debug("mediabay%d: switching to %d\n", bay->index, id);
384 set_mb_power(bay, id != MB_NO);
385 bay->content_id = id;
387 printk(KERN_INFO "mediabay%d: Bay is now empty\n", bay->index);
390 bay->index, mb_content_types[id]);
396 struct media_bay_info* bay;
403 * we may be called with the bay lock held. The resulting
407 bay = macio_get_drvdata(baydev);
408 if (bay == NULL)
410 id = bay->content_id;
411 if (bay->state != mb_up)
421 struct media_bay_info* bay;
425 bay = macio_get_drvdata(baydev);
426 if (bay == NULL)
428 mutex_lock(&bay->lock);
429 bay->user_lock = 1;
435 struct media_bay_info* bay;
439 bay = macio_get_drvdata(baydev);
440 if (bay == NULL)
442 if (bay->user_lock) {
443 bay->user_lock = 0;
444 mutex_unlock(&bay->lock);
451 struct media_bay_info* bay = data;
459 state = bay->state == mb_up ? bay->content_id : MB_NO;
471 struct media_bay_info* bay = &media_bays[i];
474 if (bay->state != mb_powering_down)
475 poll_media_bay(bay);
478 if (bay->timer != 0) {
479 bay->timer -= msecs_to_jiffies(MB_POLL_DELAY);
480 if (bay->timer > 0)
482 bay->timer = 0;
485 switch(bay->state) {
487 if (bay->ops->setup_bus(bay, bay->last_value) < 0) {
489 i, bay->content_id);
490 set_mb_power(bay, 0);
493 bay->timer = msecs_to_jiffies(MB_RESET_DELAY);
494 bay->state = mb_enabling_bay;
495 pr_debug("mediabay%d: enabling (kind:%d)\n", i, bay->content_id);
498 bay->ops->un_reset(bay);
499 bay->timer = msecs_to_jiffies(MB_SETUP_DELAY);
500 bay->state = mb_resetting;
501 pr_debug("mediabay%d: releasing bay reset (kind:%d)\n",
502 i, bay->content_id);
505 if (bay->content_id != MB_CD) {
506 pr_debug("mediabay%d: bay is up (kind:%d)\n", i,
507 bay->content_id);
508 bay->state = mb_up;
509 device_for_each_child(&bay->mdev->ofdev.dev,
510 bay, mb_broadcast_hotplug);
514 i, bay->content_id);
515 bay->ops->un_reset_ide(bay);
516 bay->timer = msecs_to_jiffies(MB_IDE_WAIT);
517 bay->state = mb_ide_resetting;
521 pr_debug("mediabay%d: bay is up (kind:%d)\n", i, bay->content_id);
522 bay->state = mb_up;
523 device_for_each_child(&bay->mdev->ofdev.dev,
524 bay, mb_broadcast_hotplug);
528 bay->state = mb_empty;
529 device_for_each_child(&bay->mdev->ofdev.dev,
530 bay, mb_broadcast_hotplug);
537 * This procedure runs as a kernel thread to poll the media bay
561 struct media_bay_info* bay;
571 if (macio_request_resources(mdev, "media-bay"))
573 /* Media bay registers are located at the beginning of the
585 bay = &media_bays[i];
586 bay->mdev = mdev;
587 bay->base = regbase;
588 bay->index = i;
589 bay->ops = match->data;
590 bay->sleeping = 0;
591 mutex_init(&bay->lock);
594 if (bay->ops->init)
595 bay->ops->init(bay);
597 printk(KERN_INFO "mediabay%d: Registered %s media-bay\n", i, bay->ops->name);
600 set_mb_power(bay, 0);
602 bay->content_id = MB_NO;
603 bay->last_value = bay->ops->content(bay);
604 bay->value_count = msecs_to_jiffies(MB_STABLE_DELAY);
605 bay->state = mb_empty;
608 macio_set_drvdata(mdev, bay);
612 kthread_run(media_bay_task, NULL, "media-bay");
620 struct media_bay_info *bay = macio_get_drvdata(mdev);
624 mutex_lock(&bay->lock);
625 bay->sleeping = 1;
626 set_mb_power(bay, 0);
627 mutex_unlock(&bay->lock);
636 struct media_bay_info *bay = macio_get_drvdata(mdev);
641 /* We re-enable the bay using it's previous content
646 mutex_lock(&bay->lock);
647 set_mb_power(bay, 0);
649 if (bay->ops->content(bay) != bay->content_id) {
650 printk("mediabay%d: Content changed during sleep...\n", bay->index);
651 mutex_unlock(&bay->lock);
654 set_mb_power(bay, 1);
655 bay->last_value = bay->content_id;
656 bay->value_count = msecs_to_jiffies(MB_STABLE_DELAY);
657 bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
660 media_bay_step(bay->index);
661 } while((bay->state != mb_empty) &&
662 (bay->state != mb_up));
663 bay->sleeping = 0;
664 mutex_unlock(&bay->lock);
701 * It seems that the bit for the media-bay interrupt in the IRQ_LEVEL
702 * register is always set when there is something in the media bay.
704 * handler to the media-bay interrupt, because it tends to go into
705 * an infinite loop calling the media bay interrupt handler.
706 * Therefore we do it all by polling the media bay once each tick.
712 .name = "media-bay",
713 .compatible = "keylargo-media-bay",
717 .name = "media-bay",
718 .compatible = "heathrow-media-bay",
722 .name = "media-bay",
723 .compatible = "ohare-media-bay",
732 .name = "media-bay",