Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/macintosh/mediabay.c

  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/types.h>
 14 #include <linux/errno.h>
 15 #include <linux/kernel.h>
 16 #include <linux/delay.h>
 17 #include <linux/sched.h>
 18 #include <linux/timer.h>
 19 #include <linux/stddef.h>
 20 #include <linux/init.h>
 21 #include <linux/kthread.h>
 22 #include <linux/mutex.h>
 23 #include <asm/prom.h>
 24 #include <asm/pgtable.h>
 25 #include <asm/io.h>
 26 #include <asm/machdep.h>
 27 #include <asm/pmac_feature.h>
 28 #include <asm/mediabay.h>
 29 #include <asm/sections.h>
 30 #include <asm/ohare.h>
 31 #include <asm/heathrow.h>
 32 #include <asm/keylargo.h>
 33 #include <linux/adb.h>
 34 #include <linux/pmu.h>
 35 
 36 #define MB_FCR32(bay, r)        ((bay)->base + ((r) >> 2))
 37 #define MB_FCR8(bay, r)         (((volatile u8 __iomem *)((bay)->base)) + (r))
 38 
 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)))
 45 
 46 struct media_bay_info;
 47 
 48 struct mb_ops {
 49         char*   name;
 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);
 56 };
 57 
 58 struct media_bay_info {
 59         u32 __iomem                     *base;
 60         int                             content_id;
 61         int                             state;
 62         int                             last_value;
 63         int                             value_count;
 64         int                             timer;
 65         struct macio_dev                *mdev;
 66         const struct mb_ops*            ops;
 67         int                             index;
 68         int                             cached_gpio;
 69         int                             sleeping;
 70         int                             user_lock;
 71         struct mutex                    lock;
 72 };
 73 
 74 #define MAX_BAYS        2
 75 
 76 static struct media_bay_info media_bays[MAX_BAYS];
 77 static int media_bay_count = 0;
 78 
 79 /*
 80  * Wait that number of ms between each step in normal polling mode
 81  */
 82 #define MB_POLL_DELAY   25
 83 
 84 /*
 85  * Consider the media-bay ID value stable if it is the same for
 86  * this number of milliseconds
 87  */
 88 #define MB_STABLE_DELAY 100
 89 
 90 /* Wait after powering up the media bay this delay in ms
 91  * timeout bumped for some powerbooks
 92  */
 93 #define MB_POWER_DELAY  200
 94 
 95 /*
 96  * Hold the media-bay reset signal true for this many ticks
 97  * after a device is inserted before releasing it.
 98  */
 99 #define MB_RESET_DELAY  50
100 
101 /*
102  * Wait this long after the reset signal is released and before doing
103  * further operations. After this delay, the IDE reset signal is released
104  * too for an IDE device
105  */
106 #define MB_SETUP_DELAY  100
107 
108 /*
109  * Wait this many ticks after an IDE device (e.g. CD-ROM) is inserted
110  * (or until the device is ready) before calling into the driver
111  */
112 #define MB_IDE_WAIT     1000
113 
114 /*
115  * States of a media bay
116  */
117 enum {
118         mb_empty = 0,           /* Idle */
119         mb_powering_up,         /* power bit set, waiting MB_POWER_DELAY */
120         mb_enabling_bay,        /* enable bits set, waiting MB_RESET_DELAY */
121         mb_resetting,           /* reset bit unset, waiting MB_SETUP_DELAY */
122         mb_ide_resetting,       /* IDE reset bit unser, waiting MB_IDE_WAIT */
123         mb_up,                  /* Media bay full */
124         mb_powering_down        /* Powering down (avoid too fast down/up) */
125 };
126 
127 #define MB_POWER_SOUND          0x08
128 #define MB_POWER_FLOPPY         0x04
129 #define MB_POWER_ATA            0x02
130 #define MB_POWER_PCI            0x01
131 #define MB_POWER_OFF            0x00
132 
133 /*
134  * Functions for polling content of media bay
135  */
136  
137 static u8
138 ohare_mb_content(struct media_bay_info *bay)
139 {
140         return (MB_IN32(bay, OHARE_MBCR) >> 12) & 7;
141 }
142 
143 static u8
144 heathrow_mb_content(struct media_bay_info *bay)
145 {
146         return (MB_IN32(bay, HEATHROW_MBCR) >> 12) & 7;
147 }
148 
149 static u8
150 keylargo_mb_content(struct media_bay_info *bay)
151 {
152         int new_gpio;
153 
154         new_gpio = MB_IN8(bay, KL_GPIO_MEDIABAY_IRQ) & KEYLARGO_GPIO_INPUT_DATA;
155         if (new_gpio) {
156                 bay->cached_gpio = new_gpio;
157                 return MB_NO;
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);
161                 udelay(5);
162                 MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
163                 (void)MB_IN32(bay, KEYLARGO_MBCR);
164                 udelay(5);
165                 bay->cached_gpio = new_gpio;
166         }
167         return (MB_IN32(bay, KEYLARGO_MBCR) >> 4) & 7;
168 }
169 
170 /*
171  * Functions for powering up/down the bay, puts the bay device
172  * into reset state as well
173  */
174 
175 static void
176 ohare_mb_power(struct media_bay_info* bay, int on_off)
177 {
178         if (on_off) {
179                 /* Power up device, assert it's reset line */
180                 MB_BIC(bay, OHARE_FCR, OH_BAY_RESET_N);
181                 MB_BIC(bay, OHARE_FCR, OH_BAY_POWER_N);
182         } else {
183                 /* Disable all devices */
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);
190         }
191         MB_BIC(bay, OHARE_MBCR, 0x00000F00);
192 }
193 
194 static void
195 heathrow_mb_power(struct media_bay_info* bay, int on_off)
196 {
197         if (on_off) {
198                 /* Power up device, assert it's reset line */
199                 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
200                 MB_BIC(bay, HEATHROW_FCR, HRW_BAY_POWER_N);
201         } else {
202                 /* Disable all devices */
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);
209         }
210         MB_BIC(bay, HEATHROW_MBCR, 0x00000F00);
211 }
212 
213 static void
214 keylargo_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, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
219                 MB_BIC(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_POWER);
220         } else {
221                 /* Disable all devices */
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);
228         }
229         MB_BIC(bay, KEYLARGO_MBCR, 0x0000000F);
230 }
231 
232 /*
233  * Functions for configuring the media bay for a given type of device,
234  * enable the related busses
235  */
236 
237 static int
238 ohare_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
239 {
240         switch(device_id) {
241                 case MB_FD:
242                 case MB_FD1:
243                         MB_BIS(bay, OHARE_FCR, OH_BAY_FLOPPY_ENABLE);
244                         MB_BIS(bay, OHARE_FCR, OH_FLOPPY_ENABLE);
245                         return 0;
246                 case MB_CD:
247                         MB_BIC(bay, OHARE_FCR, OH_IDE1_RESET_N);
248                         MB_BIS(bay, OHARE_FCR, OH_BAY_IDE_ENABLE);
249                         return 0;
250                 case MB_PCI:
251                         MB_BIS(bay, OHARE_FCR, OH_BAY_PCI_ENABLE);
252                         return 0;
253         }
254         return -ENODEV;
255 }
256 
257 static int
258 heathrow_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
259 {
260         switch(device_id) {
261                 case MB_FD:
262                 case MB_FD1:
263                         MB_BIS(bay, HEATHROW_FCR, HRW_BAY_FLOPPY_ENABLE);
264                         MB_BIS(bay, HEATHROW_FCR, HRW_SWIM_ENABLE);
265                         return 0;
266                 case MB_CD:
267                         MB_BIC(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
268                         MB_BIS(bay, HEATHROW_FCR, HRW_BAY_IDE_ENABLE);
269                         return 0;
270                 case MB_PCI:
271                         MB_BIS(bay, HEATHROW_FCR, HRW_BAY_PCI_ENABLE);
272                         return 0;
273         }
274         return -ENODEV;
275 }
276 
277 static int
278 keylargo_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
279 {
280         switch(device_id) {
281                 case MB_CD:
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);
285                         return 0;
286                 case MB_PCI:
287                         MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_PCI_ENABLE);
288                         return 0;
289                 case MB_SOUND:
290                         MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_SOUND_ENABLE);
291                         return 0;
292         }
293         return -ENODEV;
294 }
295 
296 /*
297  * Functions for tweaking resets
298  */
299 
300 static void
301 ohare_mb_un_reset(struct media_bay_info* bay)
302 {
303         MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
304 }
305 
306 static void keylargo_mb_init(struct media_bay_info *bay)
307 {
308         MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
309 }
310 
311 static void heathrow_mb_un_reset(struct media_bay_info* bay)
312 {
313         MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
314 }
315 
316 static void keylargo_mb_un_reset(struct media_bay_info* bay)
317 {
318         MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
319 }
320 
321 static void ohare_mb_un_reset_ide(struct media_bay_info* bay)
322 {
323         MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
324 }
325 
326 static void heathrow_mb_un_reset_ide(struct media_bay_info* bay)
327 {
328         MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
329 }
330 
331 static void keylargo_mb_un_reset_ide(struct media_bay_info* bay)
332 {
333         MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
334 }
335 
336 static inline void set_mb_power(struct media_bay_info* bay, int onoff)
337 {
338         /* Power up up and assert the bay reset line */
339         if (onoff) {
340                 bay->ops->power(bay, 1);
341                 bay->state = mb_powering_up;
342                 pr_debug("mediabay%d: powering up\n", bay->index);
343         } else { 
344                 /* Make sure everything is powered down & disabled */
345                 bay->ops->power(bay, 0);
346                 bay->state = mb_powering_down;
347                 pr_debug("mediabay%d: powering down\n", bay->index);
348         }
349         bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
350 }
351 
352 static void poll_media_bay(struct media_bay_info* bay)
353 {
354         int id = bay->ops->content(bay);
355 
356         static char *mb_content_types[] = {
357                 "a floppy drive",
358                 "a floppy drive",
359                 "an unsupported audio device",
360                 "an ATA device",
361                 "an unsupported PCI device",
362                 "an unknown device",
363         };
364 
365         if (id != bay->last_value) {
366                 bay->last_value = id;
367                 bay->value_count = 0;
368                 return;
369         }
370         if (id == bay->content_id)
371                 return;
372 
373         bay->value_count += msecs_to_jiffies(MB_POLL_DELAY);
374         if (bay->value_count >= msecs_to_jiffies(MB_STABLE_DELAY)) {
375                 /* If the device type changes without going thru
376                  * "MB_NO", we force a pass by "MB_NO" to make sure
377                  * things are properly reset
378                  */
379                 if ((id != MB_NO) && (bay->content_id != MB_NO)) {
380                         id = MB_NO;
381                         pr_debug("mediabay%d: forcing MB_NO\n", bay->index);
382                 }
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;
386                 if (id >= MB_NO || id < 0)
387                         printk(KERN_INFO "mediabay%d: Bay is now empty\n", bay->index);
388                 else
389                         printk(KERN_INFO "mediabay%d: Bay contains %s\n",
390                                bay->index, mb_content_types[id]);
391         }
392 }
393 
394 int check_media_bay(struct macio_dev *baydev)
395 {
396         struct media_bay_info* bay;
397         int id;
398 
399         if (baydev == NULL)
400                 return MB_NO;
401 
402         /* This returns an instant snapshot, not locking, sine
403          * we may be called with the bay lock held. The resulting
404          * fuzzyness of the result if called at the wrong time is
405          * not actually a huge deal
406          */
407         bay = macio_get_drvdata(baydev);
408         if (bay == NULL)
409                 return MB_NO;
410         id = bay->content_id;
411         if (bay->state != mb_up)
412                 return MB_NO;
413         if (id == MB_FD1)
414                 return MB_FD;
415         return id;
416 }
417 EXPORT_SYMBOL_GPL(check_media_bay);
418 
419 void lock_media_bay(struct macio_dev *baydev)
420 {
421         struct media_bay_info* bay;
422 
423         if (baydev == NULL)
424                 return;
425         bay = macio_get_drvdata(baydev);
426         if (bay == NULL)
427                 return;
428         mutex_lock(&bay->lock);
429         bay->user_lock = 1;
430 }
431 EXPORT_SYMBOL_GPL(lock_media_bay);
432 
433 void unlock_media_bay(struct macio_dev *baydev)
434 {
435         struct media_bay_info* bay;
436 
437         if (baydev == NULL)
438                 return;
439         bay = macio_get_drvdata(baydev);
440         if (bay == NULL)
441                 return;
442         if (bay->user_lock) {
443                 bay->user_lock = 0;
444                 mutex_unlock(&bay->lock);
445         }
446 }
447 EXPORT_SYMBOL_GPL(unlock_media_bay);
448 
449 static int mb_broadcast_hotplug(struct device *dev, void *data)
450 {
451         struct media_bay_info* bay = data;
452         struct macio_dev *mdev;
453         struct macio_driver *drv;
454         int state;
455 
456         if (dev->bus != &macio_bus_type)
457                 return 0;
458 
459         state = bay->state == mb_up ? bay->content_id : MB_NO;
460         if (state == MB_FD1)
461                 state = MB_FD;
462         mdev = to_macio_device(dev);
463         drv = to_macio_driver(dev->driver);
464         if (dev->driver && drv->mediabay_event)
465                 drv->mediabay_event(mdev, state);
466         return 0;
467 }
468 
469 static void media_bay_step(int i)
470 {
471         struct media_bay_info* bay = &media_bays[i];
472 
473         /* We don't poll when powering down */
474         if (bay->state != mb_powering_down)
475             poll_media_bay(bay);
476 
477         /* If timer expired run state machine */
478         if (bay->timer != 0) {
479                 bay->timer -= msecs_to_jiffies(MB_POLL_DELAY);
480                 if (bay->timer > 0)
481                         return;
482                 bay->timer = 0;
483         }
484 
485         switch(bay->state) {
486         case mb_powering_up:
487                 if (bay->ops->setup_bus(bay, bay->last_value) < 0) {
488                         pr_debug("mediabay%d: device not supported (kind:%d)\n",
489                                  i, bay->content_id);
490                         set_mb_power(bay, 0);
491                         break;
492                 }
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);
496                 break;
497         case mb_enabling_bay:
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);
503                 break;
504         case mb_resetting:
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);
511                         break;
512                 }
513                 pr_debug("mediabay%d: releasing ATA reset (kind:%d)\n",
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;
518                 break;
519 
520         case 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);
525                 break;
526 
527         case mb_powering_down:
528                 bay->state = mb_empty;
529                 device_for_each_child(&bay->mdev->ofdev.dev,
530                                       bay, mb_broadcast_hotplug);
531                 pr_debug("mediabay%d: end of power down\n", i);
532                 break;
533         }
534 }
535 
536 /*
537  * This procedure runs as a kernel thread to poll the media bay
538  * once each tick and register and unregister the IDE interface
539  * with the IDE driver.  It needs to be a thread because
540  * ide_register can't be called from interrupt context.
541  */
542 static int media_bay_task(void *x)
543 {
544         int     i;
545 
546         while (!kthread_should_stop()) {
547                 for (i = 0; i < media_bay_count; ++i) {
548                         mutex_lock(&media_bays[i].lock);
549                         if (!media_bays[i].sleeping)
550                                 media_bay_step(i);
551                         mutex_unlock(&media_bays[i].lock);
552                 }
553 
554                 msleep_interruptible(MB_POLL_DELAY);
555         }
556         return 0;
557 }
558 
559 static int media_bay_attach(struct macio_dev *mdev,
560                             const struct of_device_id *match)
561 {
562         struct media_bay_info* bay;
563         u32 __iomem *regbase;
564         struct device_node *ofnode;
565         unsigned long base;
566         int i;
567 
568         ofnode = mdev->ofdev.dev.of_node;
569 
570         if (macio_resource_count(mdev) < 1)
571                 return -ENODEV;
572         if (macio_request_resources(mdev, "media-bay"))
573                 return -EBUSY;
574         /* Media bay registers are located at the beginning of the
575          * mac-io chip, for now, we trick and align down the first
576          * resource passed in
577          */
578         base = macio_resource_start(mdev, 0) & 0xffff0000u;
579         regbase = (u32 __iomem *)ioremap(base, 0x100);
580         if (regbase == NULL) {
581                 macio_release_resources(mdev);
582                 return -ENOMEM;
583         }
584         
585         i = media_bay_count++;
586         bay = &media_bays[i];
587         bay->mdev = mdev;
588         bay->base = regbase;
589         bay->index = i;
590         bay->ops = match->data;
591         bay->sleeping = 0;
592         mutex_init(&bay->lock);
593 
594         /* Init HW probing */
595         if (bay->ops->init)
596                 bay->ops->init(bay);
597 
598         printk(KERN_INFO "mediabay%d: Registered %s media-bay\n", i, bay->ops->name);
599 
600         /* Force an immediate detect */
601         set_mb_power(bay, 0);
602         msleep(MB_POWER_DELAY);
603         bay->content_id = MB_NO;
604         bay->last_value = bay->ops->content(bay);
605         bay->value_count = msecs_to_jiffies(MB_STABLE_DELAY);
606         bay->state = mb_empty;
607 
608         /* Mark us ready by filling our mdev data */
609         macio_set_drvdata(mdev, bay);
610 
611         /* Startup kernel thread */
612         if (i == 0)
613                 kthread_run(media_bay_task, NULL, "media-bay");
614 
615         return 0;
616 
617 }
618 
619 static int media_bay_suspend(struct macio_dev *mdev, pm_message_t state)
620 {
621         struct media_bay_info   *bay = macio_get_drvdata(mdev);
622 
623         if (state.event != mdev->ofdev.dev.power.power_state.event
624             && (state.event & PM_EVENT_SLEEP)) {
625                 mutex_lock(&bay->lock);
626                 bay->sleeping = 1;
627                 set_mb_power(bay, 0);
628                 mutex_unlock(&bay->lock);
629                 msleep(MB_POLL_DELAY);
630                 mdev->ofdev.dev.power.power_state = state;
631         }
632         return 0;
633 }
634 
635 static int media_bay_resume(struct macio_dev *mdev)
636 {
637         struct media_bay_info   *bay = macio_get_drvdata(mdev);
638 
639         if (mdev->ofdev.dev.power.power_state.event != PM_EVENT_ON) {
640                 mdev->ofdev.dev.power.power_state = PMSG_ON;
641 
642                 /* We re-enable the bay using it's previous content
643                    only if it did not change. Note those bozo timings,
644                    they seem to help the 3400 get it right.
645                  */
646                 /* Force MB power to 0 */
647                 mutex_lock(&bay->lock);
648                 set_mb_power(bay, 0);
649                 msleep(MB_POWER_DELAY);
650                 if (bay->ops->content(bay) != bay->content_id) {
651                         printk("mediabay%d: Content changed during sleep...\n", bay->index);
652                         mutex_unlock(&bay->lock);
653                         return 0;
654                 }
655                 set_mb_power(bay, 1);
656                 bay->last_value = bay->content_id;
657                 bay->value_count = msecs_to_jiffies(MB_STABLE_DELAY);
658                 bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
659                 do {
660                         msleep(MB_POLL_DELAY);
661                         media_bay_step(bay->index);
662                 } while((bay->state != mb_empty) &&
663                         (bay->state != mb_up));
664                 bay->sleeping = 0;
665                 mutex_unlock(&bay->lock);
666         }
667         return 0;
668 }
669 
670 
671 /* Definitions of "ops" structures.
672  */
673 static const struct mb_ops ohare_mb_ops = {
674         .name           = "Ohare",
675         .content        = ohare_mb_content,
676         .power          = ohare_mb_power,
677         .setup_bus      = ohare_mb_setup_bus,
678         .un_reset       = ohare_mb_un_reset,
679         .un_reset_ide   = ohare_mb_un_reset_ide,
680 };
681 
682 static const struct mb_ops heathrow_mb_ops = {
683         .name           = "Heathrow",
684         .content        = heathrow_mb_content,
685         .power          = heathrow_mb_power,
686         .setup_bus      = heathrow_mb_setup_bus,
687         .un_reset       = heathrow_mb_un_reset,
688         .un_reset_ide   = heathrow_mb_un_reset_ide,
689 };
690 
691 static const struct mb_ops keylargo_mb_ops = {
692         .name           = "KeyLargo",
693         .init           = keylargo_mb_init,
694         .content        = keylargo_mb_content,
695         .power          = keylargo_mb_power,
696         .setup_bus      = keylargo_mb_setup_bus,
697         .un_reset       = keylargo_mb_un_reset,
698         .un_reset_ide   = keylargo_mb_un_reset_ide,
699 };
700 
701 /*
702  * It seems that the bit for the media-bay interrupt in the IRQ_LEVEL
703  * register is always set when there is something in the media bay.
704  * This causes problems for the interrupt code if we attach an interrupt
705  * handler to the media-bay interrupt, because it tends to go into
706  * an infinite loop calling the media bay interrupt handler.
707  * Therefore we do it all by polling the media bay once each tick.
708  */
709 
710 static struct of_device_id media_bay_match[] =
711 {
712         {
713         .name           = "media-bay",
714         .compatible     = "keylargo-media-bay",
715         .data           = &keylargo_mb_ops,
716         },
717         {
718         .name           = "media-bay",
719         .compatible     = "heathrow-media-bay",
720         .data           = &heathrow_mb_ops,
721         },
722         {
723         .name           = "media-bay",
724         .compatible     = "ohare-media-bay",
725         .data           = &ohare_mb_ops,
726         },
727         {},
728 };
729 
730 static struct macio_driver media_bay_driver =
731 {
732         .driver = {
733                 .name           = "media-bay",
734                 .of_match_table = media_bay_match,
735         },
736         .probe          = media_bay_attach,
737         .suspend        = media_bay_suspend,
738         .resume         = media_bay_resume
739 };
740 
741 static int __init media_bay_init(void)
742 {
743         int i;
744 
745         for (i=0; i<MAX_BAYS; i++) {
746                 memset((char *)&media_bays[i], 0, sizeof(struct media_bay_info));
747                 media_bays[i].content_id        = -1;
748         }
749         if (!machine_is(powermac))
750                 return 0;
751 
752         macio_register_driver(&media_bay_driver);       
753 
754         return 0;
755 }
756 
757 device_initcall(media_bay_init);
758 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us