开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mediabay.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：21k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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. #define __KERNEL_SYSCALLS__
  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>
  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
  46. #undef MB_USE_INTERRUPTS
  47. #define MB_DEBUG
  48. #define MB_IGNORE_SIGNALS
  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
  56. /* Type of media bay */
  57. enum {
  58. mb_ohare,
  59. mb_heathrow,
  60. mb_keylargo
  61. };
  63. #define MB_FCR32(bay, r) ((bay)->base + ((r) >> 2))
  64. #define MB_FCR8(bay, r) (((volatile u8*)((bay)->base)) + (r))
  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)))
  73. struct media_bay_info;
  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. };
  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. };
  104. #define MAX_BAYS 2
  106. static struct media_bay_info media_bays[MAX_BAYS];
  107. int media_bay_count = 0;
  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) ((inb(media_bays[i].cd_base + 0x70) & 0x80) == 0)
  113. #endif
  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)
  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
  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
  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
  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
  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
  150. /*
  151.  * Timeout waiting for busy bit of an IDE device to go down
  152.  */
  153. #define MB_IDE_TIMEOUT 5000
  155. /*
  156.  * Max retries of the full power up/down sequence for an IDE device
  157.  */
  158. #define MAX_CD_RETRIES 3
  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. };
  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
  180. /*
  181.  * Functions for polling content of media bay
  182.  */
  183.  
  184. static u8 __pmac
  185. ohare_mb_content(struct media_bay_info *bay)
  186. {
  187. return (MB_IN32(bay, OHARE_MBCR) >> 12) & 7;
  188. }
  190. static u8 __pmac
  191. heathrow_mb_content(struct media_bay_info *bay)
  192. {
  193. return (MB_IN32(bay, HEATHROW_MBCR) >> 12) & 7;
  194. }
  196. static u8 __pmac
  197. keylargo_mb_content(struct media_bay_info *bay)
  198. {
  199. int new_gpio;
  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. }
  217. /*
  218.  * Functions for powering up/down the bay, puts the bay device
  219.  * into reset state as well
  220.  */
  222. static void __pmac
  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. }
  241. static void __pmac
  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. }
  260. static void __pmac
  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. }
  279. /*
  280.  * Functions for configuring the media bay for a given type of device,
  281.  * enable the related busses
  282.  */
  284. static int __pmac
  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. }
  304. static int __pmac
  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. }
  324. static int __pmac
  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. }
  343. /*
  344.  * Functions for tweaking resets
  345.  */
  347. static void __pmac
  348. ohare_mb_un_reset(struct media_bay_info* bay)
  349. {
  350. MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
  351. }
  353. static void __pmac
  354. heathrow_mb_un_reset(struct media_bay_info* bay)
  355. {
  356. MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
  357. }
  359. static void __pmac
  360. keylargo_mb_un_reset(struct media_bay_info* bay)
  361. {
  362. MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
  363. }
  365. static void __pmac
  366. ohare_mb_un_reset_ide(struct media_bay_info* bay)
  367. {
  368. MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
  369. }
  371. static void __pmac
  372. heathrow_mb_un_reset_ide(struct media_bay_info* bay)
  373. {
  374. MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
  375. }
  377. static void __pmac
  378. keylargo_mb_un_reset_ide(struct media_bay_info* bay)
  379. {
  380. MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
  381. }
  383. static inline void __pmac
  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 upn", 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 downn", bay->index);
  396. }
  397. bay->timer = MS_TO_HZ(MB_POWER_DELAY);
  398. }
  400. static void __pmac
  401. poll_media_bay(struct media_bay_info* bay)
  402. {
  403. int id = bay->ops->content(bay);
  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_NOn", bay->index);
  413. }
  414. MBDBG("mediabay%d: switching to %dn", 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 emptyn", bay->index);
  422. }
  423.       }
  424. } else {
  425. bay->last_value = id;
  426. bay->value_count = 0;
  427. }
  428. }
  430. int __pmac
  431. check_media_bay(struct device_node *which_bay, int what)
  432. {
  433. #ifdef CONFIG_BLK_DEV_IDE
  434. int i;
  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. }
  448. int __pmac
  449. check_media_bay_by_base(unsigned long base, int what)
  450. {
  451. #ifdef CONFIG_BLK_DEV_IDE
  452. int i;
  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
  464. return -ENODEV;
  465. }
  467. int __pmac
  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;
  474. for (i=0; i<media_bay_count; i++)
  475. if (which_bay == media_bays[i].dev_node)
  476. {
  477. int timeout = 5000;
  479.   media_bays[i].cd_base = base;
  480. media_bays[i].cd_irq = irq;
  482. if ((MB_CD != media_bays[i].content_id) || media_bays[i].state != mb_up)
  483. return 0;
  485. printk(KERN_DEBUG "Registered ide %d for media bay %dn", 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 %dn", i);
  494. return -ENODEV;
  495. } 
  496. #endif
  498. return -ENODEV;
  499. }
  501. static void __pmac
  502. media_bay_step(int i)
  503. {
  504. struct media_bay_info* bay = &media_bays[i];
  506. /* We don't poll when powering down */
  507. if (bay->state != mb_powering_down)
  508.     poll_media_bay(bay);
  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;
  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 initn", 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 errorn");
  574. set_mb_power(bay, 0);
  575. } else {
  576. printk(KERN_DEBUG "media-bay %d is ide %dn", i, bay->cd_index);
  577. MBDBG("mediabay %d IDE readyn", i);
  578. }
  579. break;
  580.      }
  581.      if (bay->timer == 0) {
  582. printk("nIDE Timeout in bay %d !n", i);
  583. MBDBG("mediabay%d: nIDE Timeout !n", i);
  584. set_mb_power(bay, 0);
  585.      }
  586. break;
  587. #endif /* CONFIG_BLK_DEV_IDE */
  589. case mb_powering_down:
  590.      bay->state = mb_empty;
  591. #ifdef CONFIG_BLK_DEV_IDE
  592.              if (bay->cd_index >= 0) {
  593. printk(KERN_DEBUG "Unregistering mb %d ide, index:%dn", i,
  594.        bay->cd_index);
  595. ide_unregister(bay->cd_index);
  596. bay->cd_index = -1;
  597. }
  598.      if (bay->cd_retry) {
  599. if (bay->cd_retry > MAX_CD_RETRIES) {
  600. /* Should add an error sound (sort of beep in dmasound) */
  601. printk("nmedia-bay %d, IDE device badly inserted or unrecognisedn", i);
  602. } else {
  603. /* Force a new power down/up sequence */
  604. bay->content_id = MB_NO;
  605. }
  606.      }
  607. #endif /* CONFIG_BLK_DEV_IDE */    
  608. MBDBG("mediabay%d: end of power downn", i);
  609.      break;
  610. }
  611. }
  613. /*
  614.  * This procedure runs as a kernel thread to poll the media bay
  615.  * once each tick and register and unregister the IDE interface
  616.  * with the IDE driver.  It needs to be a thread because
  617.  * ide_register can't be called from interrupt context.
  618.  */
  619. static int __pmac
  620. media_bay_task(void *x)
  621. {
  622. int i;
  624. strcpy(current->comm, "media-bay");
  625. #ifdef MB_IGNORE_SIGNALS
  626. sigfillset(&current->blocked);
  627. #endif
  629. for (;;) {
  630. for (i = 0; i < media_bay_count; ++i)
  631. media_bay_step(i);
  633. current->state = TASK_INTERRUPTIBLE;
  634. schedule_timeout(1);
  635. if (signal_pending(current))
  636. return 0;
  637. }
  638. }
  640. #ifdef MB_USE_INTERRUPTS
  641. static void __pmac
  642. media_bay_intr(int irq, void *devid, struct pt_regs *regs)
  643. {
  644. }
  645. #endif
  647. #ifdef CONFIG_PMAC_PBOOK
  648. /*
  649.  * notify clients before sleep and reset bus afterwards
  650.  */
  651. int __pmac
  652. mb_notify_sleep(struct pmu_sleep_notifier *self, int when)
  653. {
  654. struct media_bay_info* bay;
  655. int i;
  657. switch (when) {
  658. case PBOOK_SLEEP_REQUEST:
  659. case PBOOK_SLEEP_REJECT:
  660. break;
  662. case PBOOK_SLEEP_NOW:
  663. for (i=0; i<media_bay_count; i++) {
  664. bay = &media_bays[i];
  665. set_mb_power(bay, 0);
  666. mdelay(10);
  667. }
  668. break;
  669. case PBOOK_WAKE:
  670. for (i=0; i<media_bay_count; i++) {
  671. bay = &media_bays[i];
  672. /* We re-enable the bay using it's previous content
  673.    only if it did not change. Note those bozo timings,
  674.    they seem to help the 3400 get it right.
  675.  */
  676. /* Force MB power to 0 */
  677. set_mb_power(bay, 0);
  678. mdelay(MB_POWER_DELAY);
  679. if (bay->ops->content(bay) != bay->content_id)
  680. continue;
  681. set_mb_power(bay, 1);
  682. bay->last_value = bay->content_id;
  683. bay->value_count = MS_TO_HZ(MB_STABLE_DELAY);
  684. bay->timer = MS_TO_HZ(MB_POWER_DELAY);
  685. #ifdef CONFIG_BLK_DEV_IDE
  686. bay->cd_retry = 0;
  687. #endif
  688. do {
  689. mdelay(1000/HZ);
  690. media_bay_step(i);
  691. } while((media_bays[i].state != mb_empty) &&
  692. (media_bays[i].state != mb_up));
  693. }
  694. break;
  695. }
  696. return PBOOK_SLEEP_OK;
  697. }
  698. #endif /* CONFIG_PMAC_PBOOK */
  701. /* Definitions of "ops" structures.
  702.  */
  703. static struct mb_ops ohare_mb_ops __pmacdata = {
  704. name: "Ohare",
  705. content: ohare_mb_content,
  706. power: ohare_mb_power,
  707. setup_bus: ohare_mb_setup_bus,
  708. un_reset: ohare_mb_un_reset,
  709. un_reset_ide: ohare_mb_un_reset_ide,
  710. };
  712. static struct mb_ops heathrow_mb_ops __pmacdata = {
  713. name: "Heathrow",
  714. content: heathrow_mb_content,
  715. power: heathrow_mb_power,
  716. setup_bus: heathrow_mb_setup_bus,
  717. un_reset: heathrow_mb_un_reset,
  718. un_reset_ide: heathrow_mb_un_reset_ide,
  719. };
  721. static struct mb_ops keylargo_mb_ops __pmacdata = {
  722. name: "KeyLargo",
  723. content: keylargo_mb_content,
  724. power: keylargo_mb_power,
  725. setup_bus: keylargo_mb_setup_bus,
  726. un_reset: keylargo_mb_un_reset,
  727. un_reset_ide: keylargo_mb_un_reset_ide,
  728. };
  730. /*
  731.  * It seems that the bit for the media-bay interrupt in the IRQ_LEVEL
  732.  * register is always set when there is something in the media bay.
  733.  * This causes problems for the interrupt code if we attach an interrupt
  734.  * handler to the media-bay interrupt, because it tends to go into
  735.  * an infinite loop calling the media bay interrupt handler.
  736.  * Therefore we do it all by polling the media bay once each tick.
  737.  */
  739. void __pmac
  740. media_bay_init(void)
  741. {
  742. struct device_node *np;
  743. int n,i;
  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. #ifdef CONFIG_BLK_DEV_IDE
  749. media_bays[i].cd_index = -1;
  750. #endif
  751. }
  753. np = find_devices("media-bay");
  754. n = 0;
  755. while(np && (n<MAX_BAYS)) {
  756. struct media_bay_info* bay = &media_bays[n];
  757. if (!np->parent || np->n_addrs == 0 || !request_OF_resource(np, 0, NULL)) {
  758. np = np->next;
  759. printk(KERN_ERR "media-bay: Can't request IO resource !n");
  760. continue;
  761. }
  762. bay->mb_type = mb_ohare;
  764. if (device_is_compatible(np, "keylargo-media-bay")) {
  765. bay->mb_type = mb_keylargo;
  766. bay->ops = &keylargo_mb_ops;
  767. } else if (device_is_compatible(np, "heathrow-media-bay")) {
  768. bay->mb_type = mb_heathrow;
  769. bay->ops = &heathrow_mb_ops;
  770. } else if (device_is_compatible(np, "ohare-media-bay")) {
  771. bay->mb_type = mb_ohare;
  772. bay->ops = &ohare_mb_ops;
  773. } else {
  774. printk(KERN_ERR "mediabay: Unknown bay type !n");
  775. np = np->next;
  776. continue;
  777. }
  778. bay->base = (volatile u32*)ioremap(np->parent->addrs[0].address, 0x1000);
  780. /* Enable probe logic on keylargo */
  781. if (bay->mb_type == mb_keylargo)
  782. MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
  783. #ifdef MB_USE_INTERRUPTS
  784. if (np->n_intrs == 0) {
  785. printk(KERN_ERR "media bay %d has no irqn",n);
  786. np = np->next;
  787. continue;
  788. }
  790. if (request_irq(np->intrs[0].line, media_bay_intr, 0, "Media bay", (void *)n)) {
  791. printk(KERN_ERR "Couldn't get IRQ %d for media bay %dn",
  792. np->intrs[0].line, n);
  793. np = np->next;
  794. continue;
  795. }
  796. #endif
  797. media_bay_count++;
  799. printk(KERN_INFO "mediabay%d: Registered %s media-bayn", n, bay->ops->name);
  800. bay->dev_node = np;
  801. bay->index = n;
  803. /* Force an immediate detect */
  804. set_mb_power(bay, 0);
  805. mdelay(MB_POWER_DELAY);
  806. bay->content_id = MB_NO;
  807. bay->last_value = bay->ops->content(bay);
  808. bay->value_count = MS_TO_HZ(MB_STABLE_DELAY);
  809. bay->state = mb_empty;
  810. do {
  811. mdelay(1000/HZ);
  812. media_bay_step(n);
  813. } while((bay->state != mb_empty) &&
  814. (bay->state != mb_up));
  816. n++;
  817. np=np->next;
  818. }
  820. if (media_bay_count)
  821. {
  822. #ifdef CONFIG_PMAC_PBOOK
  823. pmu_register_sleep_notifier(&mb_sleep_notifier);
  824. #endif /* CONFIG_PMAC_PBOOK */
  826. kernel_thread(media_bay_task, NULL,
  827.       CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
  828. }
  829. }