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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pmac_feature.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：56k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pmac_feature.c：源码内容
  1. /*
  2.  * BK Id: %F% %I% %G% %U% %#%
  3.  */
  4. /*
  5.  *  arch/ppc/kernel/pmac_feature.c
  6.  *
  7.  *  Copyright (C) 1996-2001 Paul Mackerras (paulus@cs.anu.edu.au)
  8.  *                          Ben. Herrenschmidt (benh@kernel.crashing.org)
  9.  *
  10.  *  This program is free software; you can redistribute it and/or
  11.  *  modify it under the terms of the GNU General Public License
  12.  *  as published by the Free Software Foundation; either version
  13.  *  2 of the License, or (at your option) any later version.
  14.  *  
  15.  *  TODO: 
  16.  *  
  17.  *   - Replace mdelay with some schedule loop if possible
  18.  *   - Shorten some obfuscated delays on some routines (like modem
  19.  *     power)
  20.  *
  21.  */
  22. #include <linux/config.h>
  23. #include <linux/types.h>
  24. #include <linux/init.h>
  25. #include <linux/delay.h>
  26. #include <linux/kernel.h>
  27. #include <linux/sched.h>
  28. #include <linux/spinlock.h>
  29. #include <linux/adb.h>
  30. #include <linux/pmu.h>
  31. #include <asm/sections.h>
  32. #include <asm/errno.h>
  33. #include <asm/ohare.h>
  34. #include <asm/heathrow.h>
  35. #include <asm/keylargo.h>
  36. #include <asm/uninorth.h>
  37. #include <asm/io.h>
  38. #include <asm/prom.h>
  39. #include <asm/machdep.h>
  40. #include <asm/pmac_feature.h>
  41. #include <asm/dbdma.h>
  43. #undef DEBUG_FEATURE
  45. #ifdef DEBUG_FEATURE
  46. #define DBG(fmt,...) printk(KERN_DEBUG fmt)
  47. #else
  48. #define DBG(fmt,...)
  49. #endif
  51. /* Exported from arch/ppc/kernel/idle.c */
  52. extern unsigned long powersave_nap;
  54. /*
  55.  * We use a single global lock to protect accesses. Each driver has
  56.  * to take care of it's own locking
  57.  */
  58. static spinlock_t feature_lock  __pmacdata = SPIN_LOCK_UNLOCKED;
  60. #define LOCK(flags) spin_lock_irqsave(&feature_lock, flags);
  61. #define UNLOCK(flags) spin_unlock_irqrestore(&feature_lock, flags);
  63. /*
  64.  * Helper functions regarding the various flavors of mac-io
  65.  */
  66.  
  67. #define MAX_MACIO_CHIPS 2
  69. enum {
  70. macio_unknown = 0,
  71. macio_grand_central,
  72. macio_ohare,
  73. macio_ohareII,
  74. macio_heathrow,
  75. macio_gatwick,
  76. macio_paddington,
  77. macio_keylargo,
  78. macio_pangea
  79. };
  81. static const char* macio_names[] __pmacdata = 
  82. {
  83. "Unknown",
  84. "Grand Central",
  85. "OHare",
  86. "OHareII",
  87. "Heathrow",
  88. "Gatwick",
  89. "Paddington",
  90. "Keylargo",
  91. "Pangea"
  92. };
  94. static struct macio_chip
  95. {
  96. struct device_node* of_node;
  97. int type;
  98. int rev;
  99. volatile u32* base;
  100. unsigned long flags;
  101. } macio_chips[MAX_MACIO_CHIPS]  __pmacdata;
  103. #define MACIO_FLAG_SCCA_ON 0x00000001
  104. #define MACIO_FLAG_SCCB_ON 0x00000002
  105. #define MACIO_FLAG_SCC_LOCKED 0x00000004
  106. #define MACIO_FLAG_AIRPORT_ON 0x00000010
  107. #define MACIO_FLAG_FW_SUPPORTED 0x00000020
  109. static struct macio_chip* __pmac
  110. macio_find(struct device_node* child, int type)
  111. {
  112. while(child) {
  113. int i;
  115. for (i=0; i < MAX_MACIO_CHIPS && macio_chips[i].of_node; i++)
  116. if (child == macio_chips[i].of_node &&
  117.     (!type || macio_chips[i].type == type))
  118. return &macio_chips[i];
  119. child = child->parent;
  120. }
  121. return NULL;
  122. }
  124. #define MACIO_FCR32(macio, r) ((macio)->base + ((r) >> 2))
  125. #define MACIO_FCR8(macio, r) (((volatile u8*)((macio)->base)) + (r))
  127. #define MACIO_IN32(r) (in_le32(MACIO_FCR32(macio,r)))
  128. #define MACIO_OUT32(r,v) (out_le32(MACIO_FCR32(macio,r), (v)))
  129. #define MACIO_BIS(r,v) (MACIO_OUT32((r), MACIO_IN32(r) | (v)))
  130. #define MACIO_BIC(r,v) (MACIO_OUT32((r), MACIO_IN32(r) & ~(v)))
  131. #define MACIO_IN8(r) (in_8(MACIO_FCR8(macio,r)))
  132. #define MACIO_OUT8(r,v) (out_8(MACIO_FCR8(macio,r), (v)))
  134. /*
  135.  * Uninorth reg. access. Note that Uni-N regs are big endian
  136.  */
  137.  
  138. #define UN_REG(r) (uninorth_base + ((r) >> 2))
  139. #define UN_IN(r) (in_be32(UN_REG(r)))
  140. #define UN_OUT(r,v) (out_be32(UN_REG(r), (v)))
  141. #define UN_BIS(r,v) (UN_OUT((r), UN_IN(r) | (v)))
  142. #define UN_BIC(r,v) (UN_OUT((r), UN_IN(r) & ~(v)))
  144. static struct device_node* uninorth_node __pmacdata;
  145. static u32* uninorth_base __pmacdata;
  146. static u32 uninorth_rev __pmacdata;
  149. /*
  150.  * For each motherboard family, we have a table of functions pointers
  151.  * that handle the various features.
  152.  */
  154. typedef int (*feature_call)(struct device_node* node, int param, int value);
  156. struct feature_table_entry {
  157. unsigned int selector;
  158. feature_call function;
  159. };
  161. struct pmac_mb_def
  162. {
  163. const char* model_string;
  164. const char* model_name;
  165. int model_id;
  166. struct feature_table_entry*  features;
  167. unsigned long board_flags;
  168. };
  169. static struct pmac_mb_def pmac_mb __pmacdata;
  171. /*
  172.  * Here are the chip specific feature functions
  173.  */
  175. static inline int __pmac
  176. simple_feature_tweak(struct device_node* node, int type, int reg, u32 mask, int value)
  177. {
  178. struct macio_chip* macio;
  179. unsigned long flags;
  181. macio = macio_find(node, type);
  182. if (!macio)
  183. return -ENODEV;
  184. LOCK(flags);
  185. if (value)
  186. MACIO_BIS(reg, mask);
  187. else
  188. MACIO_BIC(reg, mask);
  189. (void)MACIO_IN32(reg);
  190. UNLOCK(flags);
  192. return 0;
  193. }
  195. static int __pmac
  196. generic_scc_enable(struct device_node* node, u32 enable_mask, u32 reset_mask,
  197. int param, int value)
  198. {
  199. struct macio_chip* macio;
  200. unsigned long chan_mask;
  201. unsigned long fcr;
  202. unsigned long flags;
  204. macio = macio_find(node, 0);
  205. if (!macio)
  206. return -ENODEV;
  207. if (!strcmp(node->name, "ch-a"))
  208. chan_mask = MACIO_FLAG_SCCA_ON;
  209. else if (!strcmp(node->name, "ch-b"))
  210. chan_mask = MACIO_FLAG_SCCB_ON;
  211. else
  212. return -ENODEV;
  214. if (value) {
  215. LOCK(flags);
  216. fcr = MACIO_IN32(OHARE_FCR);
  217. /* Check if scc cell need enabling */
  218. if (!(fcr & OH_SCC_ENABLE)) {
  219. fcr |= enable_mask;
  220. MACIO_OUT32(OHARE_FCR, fcr);
  221. fcr |= reset_mask;
  222. MACIO_OUT32(OHARE_FCR, fcr);
  223. UNLOCK(flags);
  224. (void)MACIO_IN32(OHARE_FCR);
  225. mdelay(15);
  226. LOCK(flags);
  227. fcr &= ~reset_mask;
  228. MACIO_OUT32(OHARE_FCR, fcr);
  229. }
  230. if (chan_mask & MACIO_FLAG_SCCA_ON)
  231. fcr |= OH_SCCA_IO;
  232. if (chan_mask & MACIO_FLAG_SCCB_ON)
  233. fcr |= OH_SCCB_IO;
  234. MACIO_OUT32(OHARE_FCR, fcr);
  235. macio->flags |= chan_mask;
  236. UNLOCK(flags);
  237. if (param & PMAC_SCC_FLAG_XMON)
  238. macio->flags |= MACIO_FLAG_SCC_LOCKED;
  239. } else {
  240. if (macio->flags & MACIO_FLAG_SCC_LOCKED)
  241. return -EPERM;
  242. LOCK(flags);
  243. fcr = MACIO_IN32(OHARE_FCR);
  244. if (chan_mask & MACIO_FLAG_SCCA_ON)
  245. fcr &= ~OH_SCCA_IO;
  246. if (chan_mask & MACIO_FLAG_SCCB_ON)
  247. fcr &= ~OH_SCCB_IO;
  248. MACIO_OUT32(OHARE_FCR, fcr);
  249. if ((fcr & (OH_SCCA_IO | OH_SCCB_IO)) == 0) {
  250. fcr &= ~enable_mask;
  251. MACIO_OUT32(OHARE_FCR, fcr);
  252. }
  253. macio->flags &= ~(chan_mask);
  254. UNLOCK(flags);
  255. mdelay(10);
  256. }
  257. return 0;
  258. }
  260. static int __pmac
  261. ohare_scc_enable(struct device_node* node, int param, int value)
  262. {
  263. int rc;
  265. #ifdef CONFIG_ADB_PMU
  266. if (value && (param & 0xfff) == PMAC_SCC_IRDA)
  267. pmu_enable_irled(1);
  268. #endif /* CONFIG_ADB_PMU */
  269. rc = generic_scc_enable(node, OH_SCC_ENABLE, OH_SCC_RESET, param, value);
  270. #ifdef CONFIG_ADB_PMU
  271. if ((param & 0xfff) == PMAC_SCC_IRDA && (rc || !value))
  272. pmu_enable_irled(0);
  273. #endif /* CONFIG_ADB_PMU */
  274. return rc;
  275. }
  277. static int __pmac
  278. ohare_floppy_enable(struct device_node* node, int param, int value)
  279. {
  280. return simple_feature_tweak(node, macio_ohare,
  281. OHARE_FCR, OH_FLOPPY_ENABLE, value);
  282. }
  284. static int __pmac
  285. ohare_mesh_enable(struct device_node* node, int param, int value)
  286. {
  287. return simple_feature_tweak(node, macio_ohare,
  288. OHARE_FCR, OH_MESH_ENABLE, value);
  289. }
  291. static int __pmac
  292. ohare_ide_enable(struct device_node* node, int param, int value)
  293. {
  294. switch(param) {
  295.     case 0:
  296.      /* For some reason, setting the bit in set_initial_features()
  297.       * doesn't stick. I'm still investigating... --BenH.
  298.       */
  299.      if (value)
  300.      simple_feature_tweak(node, macio_ohare,
  301. OHARE_FCR, OH_IOBUS_ENABLE, 1);
  302. return simple_feature_tweak(node, macio_ohare,
  303. OHARE_FCR, OH_IDE0_ENABLE, value);
  304.     case 1:
  305. return simple_feature_tweak(node, macio_ohare,
  306. OHARE_FCR, OH_BAY_IDE_ENABLE, value);
  307.     default:
  308.      return -ENODEV;
  309. }
  310. }
  312. static int __pmac
  313. ohare_ide_reset(struct device_node* node, int param, int value)
  314. {
  315. switch(param) {
  316.     case 0:
  317. return simple_feature_tweak(node, macio_ohare,
  318. OHARE_FCR, OH_IDE0_RESET_N, !value);
  319.     case 1:
  320. return simple_feature_tweak(node, macio_ohare,
  321. OHARE_FCR, OH_IDE1_RESET_N, !value);
  322.     default:
  323.      return -ENODEV;
  324. }
  325. }
  327. static int __pmac
  328. ohare_sleep_state(struct device_node* node, int param, int value)
  329. {
  330. struct macio_chip* macio = &macio_chips[0];
  332. if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
  333. return -EPERM;
  334. if (value) {
  335. MACIO_BIC(OHARE_FCR, OH_IOBUS_ENABLE);
  336. } else {
  337. MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
  338. }
  340. return 0;
  341. }
  343. static int __pmac
  344. heathrow_scc_enable(struct device_node* node, int param, int value)
  345. {
  346. int rc;
  348. #ifdef CONFIG_ADB_PMU
  349. if (value && param == PMAC_SCC_IRDA)
  350. pmu_enable_irled(1);
  351. #endif /* CONFIG_ADB_PMU */
  352. /* Fixme: It's possible that wallstreet (heathrow) is different
  353.  * than other paddington machines. I still have to figure that
  354.  * out exactly, for now, the paddington values are used
  355.  */
  356. rc = generic_scc_enable(node, HRW_SCC_ENABLE, PADD_RESET_SCC, param, value);
  357. #ifdef CONFIG_ADB_PMU
  358. if (param == PMAC_SCC_IRDA && (rc || !value))
  359. pmu_enable_irled(0);
  360. #endif /* CONFIG_ADB_PMU */
  361. return rc;
  362. }
  364. static int __pmac
  365. heathrow_modem_enable(struct device_node* node, int param, int value)
  366. {
  367. struct macio_chip* macio;
  368. u8 gpio;
  369. unsigned long flags;
  371. macio = macio_find(node, macio_unknown);
  372. if (!macio)
  373. return -ENODEV;
  374. gpio = MACIO_IN8(HRW_GPIO_MODEM_RESET) & ~1;
  375. if (!value) {
  376. LOCK(flags);
  377. MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio);
  378. UNLOCK(flags);
  379. (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
  380. mdelay(250);
  381. }
  382. if (pmac_mb.model_id != PMAC_TYPE_YOSEMITE &&
  383.     pmac_mb.model_id != PMAC_TYPE_YIKES) {
  384.      LOCK(flags);
  385.      /* We use the paddington values as they seem to work properly
  386.       * on the wallstreet (heathrow) as well. I can't tell why we
  387.       * had to flip them on older feature.c, the fact is that new
  388.       * code uses the paddington values which are also the ones used
  389.       * in Darwin, and that works on wallstreet !
  390.       */
  391.      if (value)
  392.      MACIO_BIC(HEATHROW_FCR, PADD_MODEM_POWER_N);
  393.      else
  394.      MACIO_BIS(HEATHROW_FCR, PADD_MODEM_POWER_N);
  395.      UNLOCK(flags);
  396.      (void)MACIO_IN32(HEATHROW_FCR);
  397. mdelay(250);
  398. }
  399. if (value) {
  400. LOCK(flags);
  401. MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio | 1);
  402. (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
  403.      UNLOCK(flags); mdelay(250); LOCK(flags);
  404. MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio);
  405. (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
  406.      UNLOCK(flags); mdelay(250); LOCK(flags);
  407. MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio | 1);
  408. (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
  409.      UNLOCK(flags); mdelay(250); LOCK(flags);
  410. }
  411. return 0;
  412. }
  414. static int __pmac
  415. heathrow_floppy_enable(struct device_node* node, int param, int value)
  416. {
  417. return simple_feature_tweak(node, macio_unknown,
  418. HEATHROW_FCR,
  419. HRW_SWIM_ENABLE|HRW_BAY_FLOPPY_ENABLE,
  420. value);
  421. }
  423. static int __pmac
  424. heathrow_mesh_enable(struct device_node* node, int param, int value)
  425. {
  426. struct macio_chip* macio;
  427. unsigned long flags;
  429. macio = macio_find(node, macio_unknown);
  430. if (!macio)
  431. return -ENODEV;
  432. LOCK(flags);
  433. /* Set clear mesh cell enable */
  434. if (value)
  435. MACIO_BIS(HEATHROW_FCR, HRW_MESH_ENABLE);
  436. else
  437. MACIO_BIC(HEATHROW_FCR, HRW_MESH_ENABLE);
  438. (void)MACIO_IN32(HEATHROW_FCR);
  439. udelay(10);
  440. /* Set/Clear termination power (todo: test ! the bit value
  441.  * used by Darwin doesn't seem to match what we used so
  442.  * far. If you experience problems, turn #if 1 into #if 0
  443.  * and tell me about it --BenH.
  444.  */
  445. #if 1
  446. if (value)
  447. MACIO_BIC(HEATHROW_MBCR, 0x00000004);
  448. else
  449. MACIO_BIS(HEATHROW_MBCR, 0x00000004);
  450. #else
  451. if (value)
  452. MACIO_BIC(HEATHROW_MBCR, 0x00040000);
  453. else
  454. MACIO_BIS(HEATHROW_MBCR, 0x00040000);
  455. #endif
  456. (void)MACIO_IN32(HEATHROW_MBCR);
  457. udelay(10);
  458. UNLOCK(flags);
  460. return 0;
  461. }
  463. static int __pmac
  464. heathrow_ide_enable(struct device_node* node, int param, int value)
  465. {
  466. switch(param) {
  467.     case 0:
  468. return simple_feature_tweak(node, macio_unknown,
  469. HEATHROW_FCR, HRW_IDE0_ENABLE, value);
  470.     case 1:
  471. return simple_feature_tweak(node, macio_unknown,
  472. HEATHROW_FCR, HRW_BAY_IDE_ENABLE, value);
  473.     default:
  474.      return -ENODEV;
  475. }
  476. }
  478. static int __pmac
  479. heathrow_ide_reset(struct device_node* node, int param, int value)
  480. {
  481. switch(param) {
  482.     case 0:
  483. return simple_feature_tweak(node, macio_unknown,
  484. HEATHROW_FCR, HRW_IDE0_RESET_N, !value);
  485.     case 1:
  486. return simple_feature_tweak(node, macio_unknown,
  487. HEATHROW_FCR, HRW_IDE1_RESET_N, !value);
  488.     default:
  489.      return -ENODEV;
  490. }
  491. }
  493. static int __pmac
  494. heathrow_bmac_enable(struct device_node* node, int param, int value)
  495. {
  496. struct macio_chip* macio;
  497. unsigned long flags;
  499. macio = macio_find(node, 0);
  500. if (!macio)
  501. return -ENODEV;
  502. if (value) {
  503. LOCK(flags);
  504. MACIO_BIS(HEATHROW_FCR, HRW_BMAC_IO_ENABLE);
  505. MACIO_BIS(HEATHROW_FCR, HRW_BMAC_RESET);
  506. UNLOCK(flags);
  507. (void)MACIO_IN32(HEATHROW_FCR);
  508. mdelay(10);
  509. LOCK(flags);
  510. MACIO_BIC(HEATHROW_FCR, HRW_BMAC_RESET);
  511. UNLOCK(flags);
  512. (void)MACIO_IN32(HEATHROW_FCR);
  513. mdelay(10);
  514. } else {
  515. LOCK(flags);
  516. MACIO_BIC(HEATHROW_FCR, HRW_BMAC_IO_ENABLE);
  517. UNLOCK(flags);
  518. }
  519. return 0;
  520. }
  522. static int __pmac
  523. heathrow_sound_enable(struct device_node* node, int param, int value)
  524. {
  525. struct macio_chip* macio;
  526. unsigned long flags;
  528. /* B&W G3 and Yikes don't support that properly (the
  529.  * sound appear to never come back after beeing shut down).
  530.  */
  531. if (pmac_mb.model_id == PMAC_TYPE_YOSEMITE ||
  532.     pmac_mb.model_id == PMAC_TYPE_YIKES)
  533. return 0;
  535. macio = macio_find(node, 0);
  536. if (!macio)
  537. return -ENODEV;
  538. if (value) {
  539. LOCK(flags);
  540. MACIO_BIS(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
  541. MACIO_BIC(HEATHROW_FCR, HRW_SOUND_POWER_N);
  542. UNLOCK(flags);
  543. (void)MACIO_IN32(HEATHROW_FCR);
  544. } else {
  545. LOCK(flags);
  546. MACIO_BIS(HEATHROW_FCR, HRW_SOUND_POWER_N);
  547. MACIO_BIC(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
  548. UNLOCK(flags);
  549. }
  550. return 0;
  551. }
  553. static u32 save_fcr[5] __pmacdata;
  554. static u32 save_mbcr __pmacdata;
  555. static u32 save_gpio_levels[2] __pmacdata;
  556. static u8 save_gpio_extint[KEYLARGO_GPIO_EXTINT_CNT] __pmacdata;
  557. static u8 save_gpio_normal[KEYLARGO_GPIO_CNT] __pmacdata;
  558. static u32 save_unin_clock_ctl __pmacdata;
  559. static struct dbdma_regs save_dbdma[13] __pmacdata;
  560. static struct dbdma_regs save_alt_dbdma[13] __pmacdata;
  562. static void __pmac
  563. dbdma_save(struct macio_chip* macio, struct dbdma_regs* save)
  564. {
  565. int i;
  567. /* Save state & config of DBDMA channels */
  568. for (i=0; i<13; i++) {
  569. volatile struct dbdma_regs* chan = (volatile struct dbdma_regs*)
  570. (macio->base + ((0x8000+i*0x100)>>2));
  571. save[i].cmdptr_hi = in_le32(&chan->cmdptr_hi);
  572. save[i].cmdptr = in_le32(&chan->cmdptr);
  573. save[i].intr_sel = in_le32(&chan->intr_sel);
  574. save[i].br_sel = in_le32(&chan->br_sel);
  575. save[i].wait_sel = in_le32(&chan->wait_sel);
  576. }
  577. }
  579. static void __pmac
  580. dbdma_restore(struct macio_chip* macio, struct dbdma_regs* save)
  581. {
  582. int i;
  584. /* Save state & config of DBDMA channels */
  585. for (i=0; i<13; i++) {
  586. volatile struct dbdma_regs* chan = (volatile struct dbdma_regs*)
  587. (macio->base + ((0x8000+i*0x100)>>2));
  588. out_le32(&chan->control, (ACTIVE|DEAD|WAKE|FLUSH|PAUSE|RUN)<<16);
  589. while (in_le32(&chan->status) & ACTIVE)
  590. mb();
  591. out_le32(&chan->cmdptr_hi, save[i].cmdptr_hi);
  592. out_le32(&chan->cmdptr, save[i].cmdptr);
  593. out_le32(&chan->intr_sel, save[i].intr_sel);
  594. out_le32(&chan->br_sel, save[i].br_sel);
  595. out_le32(&chan->wait_sel, save[i].wait_sel);
  596. }
  597. }
  599. static void __pmac
  600. heathrow_sleep(struct macio_chip* macio, int secondary)
  601. {
  602. if (secondary) {
  603. dbdma_save(macio, save_alt_dbdma);
  604. save_fcr[2] = MACIO_IN32(0x38);
  605. save_fcr[3] = MACIO_IN32(0x3c);
  606. } else {
  607. dbdma_save(macio, save_dbdma);
  608. save_fcr[0] = MACIO_IN32(0x38);
  609. save_fcr[1] = MACIO_IN32(0x3c);
  610. save_mbcr = MACIO_IN32(0x34);
  611. /* Make sure sound is shut down */
  612. MACIO_BIS(HEATHROW_FCR, HRW_SOUND_POWER_N);
  613. MACIO_BIC(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
  614. /* This seems to be necessary as well or the fan
  615.  * keeps coming up and battery drains fast */
  616. MACIO_BIC(HEATHROW_FCR, HRW_IOBUS_ENABLE);
  617. }
  618. /* Make sure modem is shut down */
  619. MACIO_OUT8(HRW_GPIO_MODEM_RESET,
  620. MACIO_IN8(HRW_GPIO_MODEM_RESET) & ~1);
  621. MACIO_BIS(HEATHROW_FCR, PADD_MODEM_POWER_N);
  622. MACIO_BIC(HEATHROW_FCR, OH_SCCA_IO|OH_SCCB_IO|HRW_SCC_ENABLE);
  624. /* Let things settle */
  625. (void)MACIO_IN32(HEATHROW_FCR);
  626. mdelay(1);
  627. }
  629. static void __pmac
  630. heathrow_wakeup(struct macio_chip* macio, int secondary)
  631. {
  632. if (secondary) {
  633. MACIO_OUT32(0x38, save_fcr[2]);
  634. (void)MACIO_IN32(0x38);
  635. mdelay(1);
  636. MACIO_OUT32(0x3c, save_fcr[3]);
  637. (void)MACIO_IN32(0x38);
  638. mdelay(10);
  639. dbdma_restore(macio, save_alt_dbdma);
  640. } else {
  641. MACIO_OUT32(0x38, save_fcr[0] | HRW_IOBUS_ENABLE);
  642. (void)MACIO_IN32(0x38);
  643. mdelay(1);
  644. MACIO_OUT32(0x3c, save_fcr[1]);
  645. (void)MACIO_IN32(0x38);
  646. mdelay(1);
  647. MACIO_OUT32(0x34, save_mbcr);
  648. (void)MACIO_IN32(0x38);
  649. mdelay(10);
  650. dbdma_restore(macio, save_dbdma);
  651. }
  652. }
  654. static int __pmac
  655. heathrow_sleep_state(struct device_node* node, int param, int value)
  656. {
  657. if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
  658. return -EPERM;
  659. if (value == 1) {
  660. if (macio_chips[1].type == macio_gatwick)
  661. heathrow_sleep(&macio_chips[0], 1);
  662. heathrow_sleep(&macio_chips[0], 0);
  663. } else if (value == 0) {
  664. heathrow_wakeup(&macio_chips[0], 0);
  665. if (macio_chips[1].type == macio_gatwick)
  666. heathrow_wakeup(&macio_chips[0], 1);
  667. }
  668. return 0;
  669. }
  671. static int __pmac
  672. core99_scc_enable(struct device_node* node, int param, int value)
  673. {
  674. struct macio_chip* macio;
  675. unsigned long flags;
  676. unsigned long chan_mask;
  677. u32 fcr;
  679. macio = macio_find(node, 0);
  680. if (!macio)
  681. return -ENODEV;
  682. if (!strcmp(node->name, "ch-a"))
  683. chan_mask = MACIO_FLAG_SCCA_ON;
  684. else if (!strcmp(node->name, "ch-b"))
  685. chan_mask = MACIO_FLAG_SCCB_ON;
  686. else
  687. return -ENODEV;
  689. if (value) {
  690. int need_reset_scc = 0;
  691. int need_reset_irda = 0;
  693. LOCK(flags);
  694. fcr = MACIO_IN32(KEYLARGO_FCR0);
  695. /* Check if scc cell need enabling */
  696. if (!(fcr & KL0_SCC_CELL_ENABLE)) {
  697. fcr |= KL0_SCC_CELL_ENABLE;
  698. need_reset_scc = 1;
  699. }
  700. if (chan_mask & MACIO_FLAG_SCCA_ON) {
  701. fcr |= KL0_SCCA_ENABLE;
  702. /* Don't enable line drivers for I2S modem */
  703. if ((param & 0xfff) == PMAC_SCC_I2S1)
  704. fcr &= ~KL0_SCC_A_INTF_ENABLE;
  705. else
  706. fcr |= KL0_SCC_A_INTF_ENABLE;
  707. }
  708. if (chan_mask & MACIO_FLAG_SCCB_ON) {
  709. fcr |= KL0_SCCB_ENABLE;
  710. /* Perform irda specific inits */
  711. if ((param & 0xfff) == PMAC_SCC_IRDA) {
  712. fcr &= ~KL0_SCC_B_INTF_ENABLE;
  713. fcr |= KL0_IRDA_ENABLE;
  714. fcr |= KL0_IRDA_CLK32_ENABLE | KL0_IRDA_CLK19_ENABLE;
  715. fcr |= KL0_IRDA_SOURCE1_SEL;
  716. fcr &= ~(KL0_IRDA_FAST_CONNECT|KL0_IRDA_DEFAULT1|KL0_IRDA_DEFAULT0);
  717. fcr &= ~(KL0_IRDA_SOURCE2_SEL|KL0_IRDA_HIGH_BAND);
  718. need_reset_irda = 1;
  719. } else
  720. fcr |= KL0_SCC_B_INTF_ENABLE;
  721. }
  722. MACIO_OUT32(KEYLARGO_FCR0, fcr);
  723. macio->flags |= chan_mask;
  724. if (need_reset_scc)  {
  725. MACIO_BIS(KEYLARGO_FCR0, KL0_SCC_RESET);
  726. (void)MACIO_IN32(KEYLARGO_FCR0);
  727. UNLOCK(flags);
  728. mdelay(15);
  729. LOCK(flags);
  730. MACIO_BIC(KEYLARGO_FCR0, KL0_SCC_RESET);
  731. }
  732. if (need_reset_irda)  {
  733. MACIO_BIS(KEYLARGO_FCR0, KL0_IRDA_RESET);
  734. (void)MACIO_IN32(KEYLARGO_FCR0);
  735. UNLOCK(flags);
  736. mdelay(15);
  737. LOCK(flags);
  738. MACIO_BIC(KEYLARGO_FCR0, KL0_IRDA_RESET);
  739. }
  740. UNLOCK(flags);
  741. if (param & PMAC_SCC_FLAG_XMON)
  742. macio->flags |= MACIO_FLAG_SCC_LOCKED;
  743. } else {
  744. if (macio->flags & MACIO_FLAG_SCC_LOCKED)
  745. return -EPERM;
  746. LOCK(flags);
  747. fcr = MACIO_IN32(KEYLARGO_FCR0);
  748. if (chan_mask & MACIO_FLAG_SCCA_ON)
  749. fcr &= ~KL0_SCCA_ENABLE;
  750. if (chan_mask & MACIO_FLAG_SCCB_ON) {
  751. fcr &= ~KL0_SCCB_ENABLE;
  752. /* Perform irda specific clears */
  753. if ((param & 0xfff) == PMAC_SCC_IRDA) {
  754. fcr &= ~KL0_IRDA_ENABLE;
  755. fcr &= ~(KL0_IRDA_CLK32_ENABLE | KL0_IRDA_CLK19_ENABLE);
  756. fcr &= ~(KL0_IRDA_FAST_CONNECT|KL0_IRDA_DEFAULT1|KL0_IRDA_DEFAULT0);
  757. fcr &= ~(KL0_IRDA_SOURCE1_SEL|KL0_IRDA_SOURCE2_SEL|KL0_IRDA_HIGH_BAND);
  758. }
  759. }
  760. MACIO_OUT32(KEYLARGO_FCR0, fcr);
  761. if ((fcr & (KL0_SCCA_ENABLE | KL0_SCCB_ENABLE)) == 0) {
  762. fcr &= ~KL0_SCC_CELL_ENABLE;
  763. MACIO_OUT32(KEYLARGO_FCR0, fcr);
  764. }
  765. macio->flags &= ~(chan_mask);
  766. UNLOCK(flags);
  767. mdelay(10);
  768. }
  769. return 0;
  770. }
  772. static int __pmac
  773. core99_modem_enable(struct device_node* node, int param, int value)
  774. {
  775. struct macio_chip* macio;
  776. u8 gpio;
  777. unsigned long flags;
  779. macio = macio_find(node, 0);
  780. if (!macio)
  781. return -ENODEV;
  782. gpio = MACIO_IN8(KL_GPIO_MODEM_RESET);
  783. gpio |= KEYLARGO_GPIO_OUTPUT_ENABLE;
  784. gpio &= ~KEYLARGO_GPIO_OUTOUT_DATA;
  786. if (!value) {
  787. LOCK(flags);
  788. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
  789. UNLOCK(flags);
  790. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  791. mdelay(250);
  792. }
  793.      LOCK(flags);
  794.      if (value) {
  795.      MACIO_BIC(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
  796.      UNLOCK(flags);
  797.      (void)MACIO_IN32(KEYLARGO_FCR2);
  798. mdelay(250);
  799.      } else {
  800.      MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
  801.      UNLOCK(flags);
  802.      }
  803. if (value) {
  804. LOCK(flags);
  805. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
  806. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  807.      UNLOCK(flags); mdelay(250); LOCK(flags);
  808. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
  809. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  810.      UNLOCK(flags); mdelay(250); LOCK(flags);
  811. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
  812. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  813.      UNLOCK(flags); mdelay(250); LOCK(flags);
  814. }
  815. return 0;
  816. }
  818. static int __pmac
  819. core99_ide_enable(struct device_node* node, int param, int value)
  820. {
  821. switch(param) {
  822.     case 0:
  823. return simple_feature_tweak(node, macio_unknown,
  824. KEYLARGO_FCR1, KL1_EIDE0_ENABLE, value);
  825.     case 1:
  826. return simple_feature_tweak(node, macio_unknown,
  827. KEYLARGO_FCR1, KL1_EIDE1_ENABLE, value);
  828.     case 2:
  829. return simple_feature_tweak(node, macio_unknown,
  830. KEYLARGO_FCR1, KL1_UIDE_ENABLE, value);
  831.     default:
  832.      return -ENODEV;
  833. }
  834. }
  836. static int __pmac
  837. core99_ide_reset(struct device_node* node, int param, int value)
  838. {
  839. switch(param) {
  840.     case 0:
  841. return simple_feature_tweak(node, macio_unknown,
  842. KEYLARGO_FCR1, KL1_EIDE0_RESET_N, !value);
  843.     case 1:
  844. return simple_feature_tweak(node, macio_unknown,
  845. KEYLARGO_FCR1, KL1_EIDE1_RESET_N, !value);
  846.     case 2:
  847. return simple_feature_tweak(node, macio_unknown,
  848. KEYLARGO_FCR1, KL1_UIDE_RESET_N, !value);
  849.     default:
  850.      return -ENODEV;
  851. }
  852. }
  854. static int __pmac
  855. core99_gmac_enable(struct device_node* node, int param, int value)
  856. {
  857. unsigned long flags;
  859. LOCK(flags);
  860. if (value)
  861. UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_GMAC);
  862. else
  863. UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_GMAC);
  864. (void)UN_IN(UNI_N_CLOCK_CNTL);
  865. UNLOCK(flags);
  866. udelay(20);
  868. return 0;
  869. }
  871. static int __pmac
  872. core99_gmac_phy_reset(struct device_node* node, int param, int value)
  873. {
  874. unsigned long flags;
  875. struct macio_chip* macio;
  877. macio = &macio_chips[0];
  878. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  879. return -ENODEV;
  881. LOCK(flags);
  882. MACIO_OUT8(KL_GPIO_ETH_PHY_RESET, KEYLARGO_GPIO_OUTPUT_ENABLE);
  883. (void)MACIO_IN8(KL_GPIO_ETH_PHY_RESET);
  884. UNLOCK(flags);
  885. mdelay(10);
  886. LOCK(flags);
  887. MACIO_OUT8(KL_GPIO_ETH_PHY_RESET, KEYLARGO_GPIO_OUTPUT_ENABLE
  888. | KEYLARGO_GPIO_OUTOUT_DATA);
  889. UNLOCK(flags);
  890. mdelay(10);
  892. return 0;
  893. }
  895. static int __pmac
  896. core99_sound_chip_enable(struct device_node* node, int param, int value)
  897. {
  898. struct macio_chip* macio;
  899. unsigned long flags;
  901. macio = macio_find(node, 0);
  902. if (!macio)
  903. return -ENODEV;
  905. /* Do a better probe code, screamer G4 desktops &
  906.  * iMacs can do that too, add a recalibrate  in
  907.  * the driver as well
  908.  */
  909. if (pmac_mb.model_id == PMAC_TYPE_PISMO ||
  910.     pmac_mb.model_id == PMAC_TYPE_TITANIUM) {
  911. LOCK(flags);
  912. if (value)
  913.      MACIO_OUT8(KL_GPIO_SOUND_POWER,
  914.      KEYLARGO_GPIO_OUTPUT_ENABLE |
  915.      KEYLARGO_GPIO_OUTOUT_DATA);
  916.      else
  917.      MACIO_OUT8(KL_GPIO_SOUND_POWER,
  918.      KEYLARGO_GPIO_OUTPUT_ENABLE);
  919.      (void)MACIO_IN8(KL_GPIO_SOUND_POWER);
  920.      UNLOCK(flags);
  921. }
  922. return 0;
  923. }
  925. static int __pmac
  926. core99_airport_enable(struct device_node* node, int param, int value)
  927. {
  928. struct macio_chip* macio;
  929. unsigned long flags;
  930. int state;
  932. macio = macio_find(node, 0);
  933. if (!macio)
  934. return -ENODEV;
  936. /* Hint: we allow passing of macio itself for the sake of the
  937.  * sleep code
  938.  */
  939. if (node != macio->of_node &&
  940.     (!node->parent || node->parent != macio->of_node))
  941. return -ENODEV;
  942. state = (macio->flags & MACIO_FLAG_AIRPORT_ON) != 0;
  943. if (value == state)
  944. return 0;
  945. if (value) {
  946. /* This code is a reproduction of OF enable-cardslot
  947.  * and init-wireless methods, slightly hacked until
  948.  * I got it working.
  949.  */
  950. LOCK(flags);
  951. MACIO_OUT8(KEYLARGO_GPIO_0+0xf, 5);
  952. (void)MACIO_IN8(KEYLARGO_GPIO_0+0xf);
  953. UNLOCK(flags);
  954. mdelay(10);
  955. LOCK(flags);
  956. MACIO_OUT8(KEYLARGO_GPIO_0+0xf, 4);
  957. (void)MACIO_IN8(KEYLARGO_GPIO_0+0xf);
  958. UNLOCK(flags);
  960. mdelay(10);
  962. LOCK(flags);
  963. MACIO_BIC(KEYLARGO_FCR2, KL2_CARDSEL_16);
  964. (void)MACIO_IN32(KEYLARGO_FCR2);
  965. udelay(10);
  966. MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xb, 0);
  967. (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xb);
  968. udelay(10);
  969. MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xa, 0x28);
  970. (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xa);
  971. udelay(10);
  972. MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xd, 0x28);
  973. (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xd);
  974. udelay(10);
  975. MACIO_OUT8(KEYLARGO_GPIO_0+0xd, 0x28);
  976. (void)MACIO_IN8(KEYLARGO_GPIO_0+0xd);
  977. udelay(10);
  978. MACIO_OUT8(KEYLARGO_GPIO_0+0xe, 0x28);
  979. (void)MACIO_IN8(KEYLARGO_GPIO_0+0xe);
  980. UNLOCK(flags);
  981. udelay(10);
  982. MACIO_OUT32(0x1c000, 0);
  983. mdelay(1);
  984. MACIO_OUT8(0x1a3e0, 0x41);
  985. (void)MACIO_IN8(0x1a3e0);
  986. udelay(10);
  987. LOCK(flags);
  988. MACIO_BIS(KEYLARGO_FCR2, KL2_CARDSEL_16);
  989. (void)MACIO_IN32(KEYLARGO_FCR2);
  990. UNLOCK(flags);
  991. mdelay(100);
  993. macio->flags |= MACIO_FLAG_AIRPORT_ON;
  994. } else {
  995. LOCK(flags);
  996. MACIO_BIC(KEYLARGO_FCR2, KL2_CARDSEL_16);
  997. (void)MACIO_IN32(KEYLARGO_FCR2);
  998. MACIO_OUT8(KL_GPIO_AIRPORT_0, 0);
  999. MACIO_OUT8(KL_GPIO_AIRPORT_1, 0);
  1000. MACIO_OUT8(KL_GPIO_AIRPORT_2, 0);
  1001. MACIO_OUT8(KL_GPIO_AIRPORT_3, 0);
  1002. MACIO_OUT8(KL_GPIO_AIRPORT_4, 0);
  1003. (void)MACIO_IN8(KL_GPIO_AIRPORT_4);
  1004. UNLOCK(flags);
  1006. macio->flags &= ~MACIO_FLAG_AIRPORT_ON;
  1007. }
  1008. return 0;
  1009. }
  1011. #ifdef CONFIG_SMP
  1012. static int __pmac
  1013. core99_reset_cpu(struct device_node* node, int param, int value)
  1014. {
  1015. const int reset_lines[] = { KL_GPIO_RESET_CPU0,
  1016. KL_GPIO_RESET_CPU1,
  1017. KL_GPIO_RESET_CPU2,
  1018. KL_GPIO_RESET_CPU3 };
  1019. int reset_io;
  1020. unsigned long flags;
  1021. struct macio_chip* macio;
  1023. macio = &macio_chips[0];
  1024. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  1025. return -ENODEV;
  1026. if (param > 3 || param < 0)
  1027. return -ENODEV;
  1029. reset_io = reset_lines[param];
  1031. LOCK(flags);
  1032. MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE);
  1033. (void)MACIO_IN8(reset_io);
  1034. udelay(1);
  1035. MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE | KEYLARGO_GPIO_OUTOUT_DATA);
  1036. (void)MACIO_IN8(reset_io);
  1037. UNLOCK(flags);
  1039. return 0;
  1040. }
  1041. #endif /* CONFIG_SMP */
  1043. static int __pmac
  1044. core99_usb_enable(struct device_node* node, int param, int value)
  1045. {
  1046. struct macio_chip* macio;
  1047. unsigned long flags;
  1048. char* prop;
  1049. int number;
  1050. u32 reg;
  1052. macio = &macio_chips[0];
  1053. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  1054. return -ENODEV;
  1056. prop = (char *)get_property(node, "AAPL,clock-id", NULL);
  1057. if (!prop)
  1058. return -ENODEV;
  1059. if (strncmp(prop, "usb0u048", strlen("usb0u048")) == 0)
  1060. number = 0;
  1061. else if (strncmp(prop, "usb1u148", strlen("usb1u148")) == 0)
  1062. number = 2;
  1063. else
  1064. return -ENODEV;
  1066. /* Sorry for the brute-force locking, but this is only used during
  1067.  * sleep and the timing seem to be critical
  1068.  */
  1069. LOCK(flags);
  1070. if (value) {
  1071. /* Turn ON */
  1072. if (number == 0) {
  1073. MACIO_BIC(KEYLARGO_FCR0, (KL0_USB0_PAD_SUSPEND0 | KL0_USB0_PAD_SUSPEND1));
  1074. (void)MACIO_IN32(KEYLARGO_FCR0);
  1075. UNLOCK(flags);
  1076. mdelay(1);
  1077. LOCK(flags);
  1078. MACIO_BIS(KEYLARGO_FCR0, KL0_USB0_CELL_ENABLE);
  1079. } else {
  1080. MACIO_BIC(KEYLARGO_FCR0, (KL0_USB1_PAD_SUSPEND0 | KL0_USB1_PAD_SUSPEND1));
  1081. UNLOCK(flags);
  1082. (void)MACIO_IN32(KEYLARGO_FCR0);
  1083. mdelay(1);
  1084. LOCK(flags);
  1085. MACIO_BIS(KEYLARGO_FCR0, KL0_USB1_CELL_ENABLE);
  1086. }
  1087. reg = MACIO_IN32(KEYLARGO_FCR4);
  1088. reg &= ~(KL4_PORT_WAKEUP_ENABLE(number) | KL4_PORT_RESUME_WAKE_EN(number) |
  1089. KL4_PORT_CONNECT_WAKE_EN(number) | KL4_PORT_DISCONNECT_WAKE_EN(number));
  1090. reg &= ~(KL4_PORT_WAKEUP_ENABLE(number+1) | KL4_PORT_RESUME_WAKE_EN(number+1) |
  1091. KL4_PORT_CONNECT_WAKE_EN(number+1) | KL4_PORT_DISCONNECT_WAKE_EN(number+1));
  1092. MACIO_OUT32(KEYLARGO_FCR4, reg);
  1093. (void)MACIO_IN32(KEYLARGO_FCR4);
  1094. udelay(10);
  1095. } else {
  1096. /* Turn OFF */
  1097. reg = MACIO_IN32(KEYLARGO_FCR4);
  1098. reg |= KL4_PORT_WAKEUP_ENABLE(number) | KL4_PORT_RESUME_WAKE_EN(number) |
  1099. KL4_PORT_CONNECT_WAKE_EN(number) | KL4_PORT_DISCONNECT_WAKE_EN(number);
  1100. reg |= KL4_PORT_WAKEUP_ENABLE(number+1) | KL4_PORT_RESUME_WAKE_EN(number+1) |
  1101. KL4_PORT_CONNECT_WAKE_EN(number+1) | KL4_PORT_DISCONNECT_WAKE_EN(number+1);
  1102. MACIO_OUT32(KEYLARGO_FCR4, reg);
  1103. (void)MACIO_IN32(KEYLARGO_FCR4);
  1104. udelay(1);
  1105. if (number == 0) {
  1106. MACIO_BIC(KEYLARGO_FCR0, KL0_USB0_CELL_ENABLE);
  1107. (void)MACIO_IN32(KEYLARGO_FCR0);
  1108. udelay(1);
  1109. MACIO_BIS(KEYLARGO_FCR0, (KL0_USB0_PAD_SUSPEND0 | KL0_USB0_PAD_SUSPEND1));
  1110. (void)MACIO_IN32(KEYLARGO_FCR0);
  1111. } else {
  1112. MACIO_BIC(KEYLARGO_FCR0, KL0_USB1_CELL_ENABLE);
  1113. (void)MACIO_IN32(KEYLARGO_FCR0);
  1114. udelay(1);
  1115. MACIO_BIS(KEYLARGO_FCR0, (KL0_USB1_PAD_SUSPEND0 | KL0_USB1_PAD_SUSPEND1));
  1116. (void)MACIO_IN32(KEYLARGO_FCR0);
  1117. }
  1118. udelay(1);
  1119. }
  1120. UNLOCK(flags);
  1122. return 0;
  1123. }
  1125. static int __pmac
  1126. core99_firewire_enable(struct device_node* node, int param, int value)
  1127. {
  1128. unsigned long flags;
  1129. struct macio_chip* macio;
  1131. macio = &macio_chips[0];
  1132. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  1133. return -ENODEV;
  1134. if (!(macio->flags & MACIO_FLAG_FW_SUPPORTED))
  1135. return -ENODEV;
  1137. LOCK(flags);
  1138. if (value) {
  1139. UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_FW);
  1140. (void)UN_IN(UNI_N_CLOCK_CNTL);
  1141. } else {
  1142. UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_FW);
  1143. (void)UN_IN(UNI_N_CLOCK_CNTL);
  1144. }
  1145. UNLOCK(flags);
  1146. mdelay(1);
  1148. return 0;
  1149. }
  1151. static int __pmac
  1152. core99_firewire_cable_power(struct device_node* node, int param, int value)
  1153. {
  1154. unsigned long flags;
  1155. struct macio_chip* macio;
  1157. /* Trick: we allow NULL node */
  1158. if ((pmac_mb.board_flags & PMAC_MB_HAS_FW_POWER) == 0)
  1159.      return -ENODEV;
  1160. macio = &macio_chips[0];
  1161. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  1162. return -ENODEV;
  1163. if (!(macio->flags & MACIO_FLAG_FW_SUPPORTED))
  1164. return -ENODEV;
  1166. LOCK(flags);
  1167. if (value) {
  1168. MACIO_OUT8(KL_GPIO_FW_CABLE_POWER , 0);
  1169. MACIO_IN8(KL_GPIO_FW_CABLE_POWER);
  1170. udelay(10);
  1171. } else {
  1172. MACIO_OUT8(KL_GPIO_FW_CABLE_POWER , 4);
  1173. MACIO_IN8(KL_GPIO_FW_CABLE_POWER); udelay(10);
  1174. }
  1175. UNLOCK(flags);
  1176. mdelay(1);
  1178. return 0;
  1179. }
  1181. static int __pmac
  1182. core99_read_gpio(struct device_node* node, int param, int value)
  1183. {
  1184. struct macio_chip* macio = &macio_chips[0];
  1186. return MACIO_IN8(param);
  1187. }
  1190. static int __pmac
  1191. core99_write_gpio(struct device_node* node, int param, int value)
  1192. {
  1193. struct macio_chip* macio = &macio_chips[0];
  1195. MACIO_OUT8(param, (u8)(value & 0xff));
  1196. return 0;
  1197. }
  1199. static void __pmac
  1200. keylargo_shutdown(struct macio_chip* macio, int restart)
  1201. {
  1202. u32 temp;
  1204. mdelay(1);
  1205. MACIO_BIS(KEYLARGO_FCR0, KL0_USB_REF_SUSPEND);
  1206. (void)MACIO_IN32(KEYLARGO_FCR0);
  1207. mdelay(100);
  1209. MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
  1210. KL0_SCC_CELL_ENABLE |
  1211.        KL0_IRDA_ENABLE | KL0_IRDA_CLK32_ENABLE |
  1212.        KL0_IRDA_CLK19_ENABLE);
  1214. (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
  1215. MACIO_BIC(KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
  1216. (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
  1218. MACIO_BIC(KEYLARGO_FCR1,
  1219. KL1_AUDIO_SEL_22MCLK | KL1_AUDIO_CLK_ENABLE_BIT |
  1220. KL1_AUDIO_CLK_OUT_ENABLE | KL1_AUDIO_CELL_ENABLE |
  1221. KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
  1222. KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
  1223. KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE |
  1224. KL1_EIDE0_ENABLE | KL1_EIDE0_RESET_N |
  1225. KL1_EIDE1_ENABLE | KL1_EIDE1_RESET_N |
  1226. KL1_UIDE_ENABLE);
  1227. (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
  1229. MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
  1230.   udelay(10);
  1231.   MACIO_BIC(KEYLARGO_FCR2, KL2_IOBUS_ENABLE);
  1232.   udelay(10);
  1233. temp = MACIO_IN32(KEYLARGO_FCR3);
  1234. if (macio->rev >= 2)
  1235. temp |= (KL3_SHUTDOWN_PLL2X | KL3_SHUTDOWN_PLL_TOTAL);
  1237. temp |= KL3_SHUTDOWN_PLLKW6 | KL3_SHUTDOWN_PLLKW4 |
  1238. KL3_SHUTDOWN_PLLKW35 | KL3_SHUTDOWN_PLLKW12;
  1239. temp &= ~(KL3_CLK66_ENABLE | KL3_CLK49_ENABLE | KL3_CLK45_ENABLE
  1240. | KL3_CLK31_ENABLE | KL3_TIMER_CLK18_ENABLE | KL3_I2S1_CLK18_ENABLE
  1241. | KL3_I2S0_CLK18_ENABLE | KL3_VIA_CLK16_ENABLE);
  1242. MACIO_OUT32(KEYLARGO_FCR3, temp);
  1243. (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
  1244. }
  1246. static void __pmac
  1247. pangea_shutdown(struct macio_chip* macio, int restart)
  1248. {
  1249. u32 temp;
  1251. MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
  1252. KL0_SCC_CELL_ENABLE |
  1253. KL0_USB0_CELL_ENABLE | KL0_USB1_CELL_ENABLE);
  1255. (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
  1256. MACIO_BIC(KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
  1257. (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
  1259. MACIO_BIC(KEYLARGO_FCR1,
  1260. KL1_AUDIO_SEL_22MCLK | KL1_AUDIO_CLK_ENABLE_BIT |
  1261. KL1_AUDIO_CLK_OUT_ENABLE | KL1_AUDIO_CELL_ENABLE |
  1262. KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
  1263. KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
  1264. KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE |
  1265. KL1_UIDE_ENABLE);
  1266. (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
  1268. MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
  1269.   udelay(10);
  1270. temp = MACIO_IN32(KEYLARGO_FCR3);
  1271. temp |= KL3_SHUTDOWN_PLLKW6 | KL3_SHUTDOWN_PLLKW4 |
  1272. KL3_SHUTDOWN_PLLKW35;
  1273. temp &= ~(KL3_CLK49_ENABLE | KL3_CLK45_ENABLE
  1274. | KL3_CLK31_ENABLE | KL3_TIMER_CLK18_ENABLE | KL3_I2S1_CLK18_ENABLE
  1275. | KL3_I2S0_CLK18_ENABLE | KL3_VIA_CLK16_ENABLE);
  1276. MACIO_OUT32(KEYLARGO_FCR3, temp);
  1277. (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
  1278. }
  1280. static int __pmac
  1281. core99_sleep(void)
  1282. {
  1283. struct macio_chip* macio;
  1284. int i;
  1286. macio = &macio_chips[0];
  1287. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  1288. return -ENODEV;
  1290. /* We power off the wireless slot in case it was not done
  1291.  * by the driver. We don't power it on automatically however
  1292.  */
  1293. if (macio->flags & MACIO_FLAG_AIRPORT_ON)
  1294. core99_airport_enable(macio->of_node, 0, 0);
  1296. /* We power off the FW cable. Should be done by the driver... */
  1297. if (macio->flags & MACIO_FLAG_FW_SUPPORTED) {
  1298. core99_firewire_enable(NULL, 0, 0);
  1299. core99_firewire_cable_power(NULL, 0, 0);
  1300. }
  1302. /* We make sure int. modem is off (in case driver lost it) */
  1303. core99_modem_enable(macio->of_node, 0, 0);
  1304. /* We make sure the sound is off as well */
  1305. core99_sound_chip_enable(macio->of_node, 0, 0);
  1306.  
  1307. /*
  1308.  * Save various bits of KeyLargo
  1309.  */
  1311. /* Save the state of the various GPIOs */
  1312. save_gpio_levels[0] = MACIO_IN32(KEYLARGO_GPIO_LEVELS0);
  1313. save_gpio_levels[1] = MACIO_IN32(KEYLARGO_GPIO_LEVELS1);
  1314. for (i=0; i<KEYLARGO_GPIO_EXTINT_CNT; i++)
  1315. save_gpio_extint[i] = MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+i);
  1316. for (i=0; i<KEYLARGO_GPIO_CNT; i++)
  1317. save_gpio_normal[i] = MACIO_IN8(KEYLARGO_GPIO_0+i);
  1319. /* Save the FCRs */
  1320. save_mbcr = MACIO_IN32(KEYLARGO_MBCR);
  1321. save_fcr[0] = MACIO_IN32(KEYLARGO_FCR0);
  1322. save_fcr[1] = MACIO_IN32(KEYLARGO_FCR1);
  1323. save_fcr[2] = MACIO_IN32(KEYLARGO_FCR2);
  1324. save_fcr[3] = MACIO_IN32(KEYLARGO_FCR3);
  1325. save_fcr[4] = MACIO_IN32(KEYLARGO_FCR4);
  1327. /* Save state & config of DBDMA channels */
  1328. dbdma_save(macio, save_dbdma);
  1330. /*
  1331.  * Turn off as much as we can
  1332.  */
  1333. if (macio->type == macio_pangea)
  1334. pangea_shutdown(macio, 0);
  1335. else if (macio->type == macio_keylargo)
  1336. keylargo_shutdown(macio, 0);
  1338. /* 
  1339.  * Put the host bridge to sleep
  1340.  */
  1342. save_unin_clock_ctl = UN_IN(UNI_N_CLOCK_CNTL);
  1343. UN_OUT(UNI_N_CLOCK_CNTL, save_unin_clock_ctl &
  1344. ~(UNI_N_CLOCK_CNTL_GMAC|UNI_N_CLOCK_CNTL_FW/*|UNI_N_CLOCK_CNTL_PCI*/));
  1345. udelay(100);
  1346. UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_SLEEPING);
  1347. UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_SLEEP);
  1349. /*
  1350.  * FIXME: A bit of black magic with OpenPIC (don't ask me why)
  1351.  */
  1352. if (pmac_mb.model_id == PMAC_TYPE_SAWTOOTH) {
  1353. MACIO_BIS(0x506e0, 0x00400000);
  1354. MACIO_BIS(0x506e0, 0x80000000);
  1355. }
  1356. return 0;
  1357. }
  1359. static int __pmac
  1360. core99_wake_up(void)
  1361. {
  1362. struct macio_chip* macio;
  1363. int i;
  1365. macio = &macio_chips[0];
  1366. if (macio->type != macio_keylargo && macio->type != macio_pangea)
  1367. return -ENODEV;
  1369. /*
  1370.  * Wakeup the host bridge
  1371.  */
  1372. UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_NORMAL);
  1373. udelay(10);
  1374. UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_RUNNING);
  1375. udelay(10);
  1377. /*
  1378.  * Restore KeyLargo
  1379.  */
  1380.  
  1381. MACIO_OUT32(KEYLARGO_MBCR, save_mbcr);
  1382. (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
  1383. MACIO_OUT32(KEYLARGO_FCR0, save_fcr[0]);
  1384. (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
  1385. MACIO_OUT32(KEYLARGO_FCR1, save_fcr[1]);
  1386. (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
  1387. MACIO_OUT32(KEYLARGO_FCR2, save_fcr[2]);
  1388. (void)MACIO_IN32(KEYLARGO_FCR2); udelay(10);
  1389. MACIO_OUT32(KEYLARGO_FCR3, save_fcr[3]);
  1390. (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
  1391. MACIO_OUT32(KEYLARGO_FCR4, save_fcr[4]);
  1392. (void)MACIO_IN32(KEYLARGO_FCR4); udelay(10);
  1394. dbdma_restore(macio, save_dbdma);
  1396. MACIO_OUT32(KEYLARGO_GPIO_LEVELS0, save_gpio_levels[0]);
  1397. MACIO_OUT32(KEYLARGO_GPIO_LEVELS1, save_gpio_levels[1]);
  1398. for (i=0; i<KEYLARGO_GPIO_EXTINT_CNT; i++)
  1399. MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+i, save_gpio_extint[i]);
  1400. for (i=0; i<KEYLARGO_GPIO_CNT; i++)
  1401. MACIO_OUT8(KEYLARGO_GPIO_0+i, save_gpio_normal[i]);
  1403. /* FIXME more black magic with OpenPIC ... */
  1404. if (pmac_mb.model_id == PMAC_TYPE_SAWTOOTH) {
  1405. MACIO_BIC(0x506e0, 0x00400000);
  1406. MACIO_BIC(0x506e0, 0x80000000);
  1407. }
  1409. UN_OUT(UNI_N_CLOCK_CNTL, save_unin_clock_ctl);
  1410. udelay(100);
  1412. return 0;
  1413. }
  1415. static int __pmac
  1416. core99_sleep_state(struct device_node* node, int param, int value)
  1417. {
  1418. if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
  1419. return -EPERM;
  1420. if (value == 1)
  1421. return core99_sleep();
  1422. else if (value == 0)
  1423. return core99_wake_up();
  1424. return 0;
  1425. }
  1427. static int __pmac
  1428. pangea_modem_enable(struct device_node* node, int param, int value)
  1429. {
  1430. struct macio_chip* macio;
  1431. u8 gpio;
  1432. unsigned long flags;
  1434. macio = macio_find(node, 0);
  1435. if (!macio)
  1436. return -ENODEV;
  1437. gpio = MACIO_IN8(KL_GPIO_MODEM_RESET);
  1438. gpio |= KEYLARGO_GPIO_OUTPUT_ENABLE;
  1439. gpio &= ~KEYLARGO_GPIO_OUTOUT_DATA;
  1441. if (!value) {
  1442. LOCK(flags);
  1443. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
  1444. UNLOCK(flags);
  1445. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  1446. mdelay(250);
  1447. }
  1448.      LOCK(flags);
  1449. if (value) {
  1450. MACIO_OUT8(KL_GPIO_MODEM_POWER,
  1451. KEYLARGO_GPIO_OUTPUT_ENABLE);
  1452.      UNLOCK(flags);
  1453.      (void)MACIO_IN32(KEYLARGO_FCR2);
  1454. mdelay(250);
  1455. } else {
  1456. MACIO_OUT8(KL_GPIO_MODEM_POWER,
  1457. KEYLARGO_GPIO_OUTPUT_ENABLE | KEYLARGO_GPIO_OUTOUT_DATA);
  1458.      UNLOCK(flags);
  1459. }
  1460. if (value) {
  1461. LOCK(flags);
  1462. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
  1463. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  1464.      UNLOCK(flags); mdelay(250); LOCK(flags);
  1465. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
  1466. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  1467.      UNLOCK(flags); mdelay(250); LOCK(flags);
  1468. MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
  1469. (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
  1470.      UNLOCK(flags); mdelay(250); LOCK(flags);
  1471. }
  1472. return 0;
  1473. }
  1476. static int __pmac
  1477. generic_get_mb_info(struct device_node* node, int param, int value)
  1478. {
  1479. switch(param) {
  1480. case PMAC_MB_INFO_MODEL:
  1481. return pmac_mb.model_id;
  1482. case PMAC_MB_INFO_FLAGS:
  1483. return pmac_mb.board_flags;
  1484. case PMAC_MB_INFO_NAME:
  1485. /* hack hack hack... but should work */
  1486. return (int)pmac_mb.model_name;
  1487. }
  1488. return 0;
  1489. }
  1492. /* 
  1493.  * Table definitions
  1494.  */
  1495.  
  1496. /* Used on any machine
  1497.  */
  1498. static struct feature_table_entry any_features[]  __pmacdata = {
  1499. { PMAC_FTR_GET_MB_INFO, generic_get_mb_info },
  1500. { 0, NULL }
  1501. };
  1503. /* OHare based motherboards. Currently, we only use these on the
  1504.  * 2400,3400 and 3500 series powerbooks. Some older desktops seem
  1505.  * to have issues with turning on/off those asic cells
  1506.  */
  1507. static struct feature_table_entry ohare_features[]  __pmacdata = {
  1508. { PMAC_FTR_SCC_ENABLE, ohare_scc_enable },
  1509. { PMAC_FTR_SWIM3_ENABLE, ohare_floppy_enable },
  1510. { PMAC_FTR_MESH_ENABLE, ohare_mesh_enable },
  1511. { PMAC_FTR_IDE_ENABLE, ohare_ide_enable},
  1512. { PMAC_FTR_IDE_RESET, ohare_ide_reset},
  1513. { PMAC_FTR_SLEEP_STATE, ohare_sleep_state },
  1514. { 0, NULL }
  1515. };
  1517. /* Heathrow desktop machines (Beige G3).
  1518.  * Separated as some features couldn't be properly tested
  1519.  * and the serial port control bits appear to confuse it.
  1520.  */
  1521. static struct feature_table_entry heathrow_desktop_features[]  __pmacdata = {
  1522. { PMAC_FTR_SWIM3_ENABLE, heathrow_floppy_enable },
  1523. { PMAC_FTR_MESH_ENABLE, heathrow_mesh_enable },
  1524. { PMAC_FTR_IDE_ENABLE, heathrow_ide_enable },
  1525. { PMAC_FTR_IDE_RESET, heathrow_ide_reset },
  1526. { PMAC_FTR_BMAC_ENABLE, heathrow_bmac_enable },
  1527. { 0, NULL }
  1528. };
  1530. /* Heathrow based laptop, that is the Wallstreet and mainstreet
  1531.  * powerbooks.
  1532.  */
  1533. static struct feature_table_entry heathrow_laptop_features[]  __pmacdata = {
  1534. { PMAC_FTR_SCC_ENABLE, heathrow_scc_enable },
  1535. { PMAC_FTR_MODEM_ENABLE, heathrow_modem_enable },
  1536. { PMAC_FTR_SWIM3_ENABLE, heathrow_floppy_enable },
  1537. { PMAC_FTR_MESH_ENABLE, heathrow_mesh_enable },
  1538. { PMAC_FTR_IDE_ENABLE, heathrow_ide_enable },
  1539. { PMAC_FTR_IDE_RESET, heathrow_ide_reset },
  1540. { PMAC_FTR_BMAC_ENABLE, heathrow_bmac_enable },
  1541. { PMAC_FTR_SOUND_CHIP_ENABLE, heathrow_sound_enable },
  1542. { PMAC_FTR_SLEEP_STATE, heathrow_sleep_state },
  1543. { 0, NULL }
  1544. };
  1546. /* Paddington based machines
  1547.  * The lombard (101) powerbook, first iMac models, B&W G3 and Yikes G4.
  1548.  */
  1549. static struct feature_table_entry paddington_features[]  __pmacdata = {
  1550. { PMAC_FTR_SCC_ENABLE, heathrow_scc_enable },
  1551. { PMAC_FTR_MODEM_ENABLE, heathrow_modem_enable },
  1552. { PMAC_FTR_SWIM3_ENABLE, heathrow_floppy_enable },
  1553. { PMAC_FTR_MESH_ENABLE, heathrow_mesh_enable },
  1554. { PMAC_FTR_IDE_ENABLE, heathrow_ide_enable },
  1555. { PMAC_FTR_IDE_RESET, heathrow_ide_reset },
  1556. { PMAC_FTR_BMAC_ENABLE, heathrow_bmac_enable },
  1557. { PMAC_FTR_SOUND_CHIP_ENABLE, heathrow_sound_enable },
  1558. { PMAC_FTR_SLEEP_STATE, heathrow_sleep_state },
  1559. { 0, NULL }
  1560. };
  1562. /* Core99 & MacRISC 2 machines (all machines released since the
  1563.  * iBook (included), that is all AGP machines, except pangea
  1564.  * chipset. The pangea chipset is the "combo" UniNorth/KeyLargo
  1565.  * used on iBook2 & iMac "flow power".
  1566.  */
  1567. static struct feature_table_entry core99_features[]  __pmacdata = {
  1568. { PMAC_FTR_SCC_ENABLE, core99_scc_enable },
  1569. { PMAC_FTR_MODEM_ENABLE, core99_modem_enable },
  1570. { PMAC_FTR_IDE_ENABLE, core99_ide_enable },
  1571. { PMAC_FTR_IDE_RESET, core99_ide_reset },
  1572. { PMAC_FTR_GMAC_ENABLE, core99_gmac_enable },
  1573. { PMAC_FTR_GMAC_PHY_RESET, core99_gmac_phy_reset },
  1574. { PMAC_FTR_SOUND_CHIP_ENABLE, core99_sound_chip_enable },
  1575. { PMAC_FTR_AIRPORT_ENABLE, core99_airport_enable },
  1576. { PMAC_FTR_USB_ENABLE, core99_usb_enable },
  1577. { PMAC_FTR_1394_ENABLE, core99_firewire_enable },
  1578. { PMAC_FTR_1394_CABLE_POWER, core99_firewire_cable_power },
  1579. { PMAC_FTR_SLEEP_STATE, core99_sleep_state },
  1580. #ifdef CONFIG_SMP
  1581. { PMAC_FTR_RESET_CPU, core99_reset_cpu },
  1582. #endif /* CONFIG_SMP */
  1583. { PMAC_FTR_READ_GPIO, core99_read_gpio },
  1584. { PMAC_FTR_WRITE_GPIO, core99_write_gpio },
  1585. { 0, NULL }
  1586. };
  1588. /* Pangea features
  1589.  */
  1590. static struct feature_table_entry pangea_features[]  __pmacdata = {
  1591. { PMAC_FTR_SCC_ENABLE, core99_scc_enable },
  1592. { PMAC_FTR_MODEM_ENABLE, pangea_modem_enable },
  1593. { PMAC_FTR_IDE_ENABLE, core99_ide_enable },
  1594. { PMAC_FTR_IDE_RESET, core99_ide_reset },
  1595. { PMAC_FTR_GMAC_ENABLE, core99_gmac_enable },
  1596. { PMAC_FTR_GMAC_PHY_RESET, core99_gmac_phy_reset },
  1597. { PMAC_FTR_SOUND_CHIP_ENABLE, core99_sound_chip_enable },
  1598. { PMAC_FTR_AIRPORT_ENABLE, core99_airport_enable },
  1599. { PMAC_FTR_USB_ENABLE, core99_usb_enable },
  1600. { PMAC_FTR_1394_ENABLE, core99_firewire_enable },
  1601. { PMAC_FTR_1394_CABLE_POWER, core99_firewire_cable_power },
  1602. { PMAC_FTR_SLEEP_STATE, core99_sleep_state },
  1603. { PMAC_FTR_READ_GPIO, core99_read_gpio },
  1604. { PMAC_FTR_WRITE_GPIO, core99_write_gpio },
  1605. { 0, NULL }
  1606. };
  1608. static struct pmac_mb_def pmac_mb_defs[] __pmacdata = {
  1609. /* Warning: ordering is important as some models may claim
  1610.  * beeing compatible with several types
  1611.  */
  1612. { "AAPL,8500", "PowerMac 8500/8600",
  1613. PMAC_TYPE_PSURGE, NULL,
  1614. 0
  1615. },
  1616. { "AAPL,9500", "PowerMac 9500/9600",
  1617. PMAC_TYPE_PSURGE, NULL,
  1618. 0
  1619. },
  1620. { "AAPL,7500", "PowerMac 7500",
  1621. PMAC_TYPE_PSURGE, NULL,
  1622. 0
  1623. },
  1624. { "AAPL,e407", "Alchemy",
  1625. PMAC_TYPE_ALCHEMY, NULL,
  1626. 0
  1627. },
  1628. { "AAPL,e411", "Gazelle",
  1629. PMAC_TYPE_GAZELLE, NULL,
  1630. 0
  1631. },
  1632. { "AAPL,3400/2400", "PowerBook 3400",
  1633. PMAC_TYPE_HOOPER, ohare_features,
  1634. PMAC_MB_CAN_SLEEP
  1635. },
  1636. { "AAPL,3500", "PowerBook 3500",
  1637. PMAC_TYPE_KANGA, ohare_features,
  1638. PMAC_MB_CAN_SLEEP
  1639. },
  1640. { "AAPL,Gossamer", "PowerMac G3 (Gossamer)",
  1641. PMAC_TYPE_GOSSAMER, heathrow_desktop_features,
  1642. 0
  1643. },
  1644. { "AAPL,PowerMac G3", "PowerMac G3 (Silk)",
  1645. PMAC_TYPE_SILK, heathrow_desktop_features,
  1646. 0
  1647. },
  1648. { "AAPL,PowerBook1998", "PowerBook Wallstreet",
  1649. PMAC_TYPE_WALLSTREET, heathrow_laptop_features,
  1650. PMAC_MB_CAN_SLEEP
  1651. },
  1652. { "AAPL,PowerBook1,1", "PowerBook 101 (Lombard)",
  1653. PMAC_TYPE_101_PBOOK, paddington_features,
  1654. PMAC_MB_CAN_SLEEP
  1655. },
  1656. { "iMac,1", "iMac (first generation)",
  1657. PMAC_TYPE_ORIG_IMAC, paddington_features,
  1658. 0
  1659. },
  1660. { "PowerMac4,1", "iMac "Flower Power"",
  1661. PMAC_TYPE_PANGEA_IMAC, pangea_features,
  1662. PMAC_MB_CAN_SLEEP
  1663. },
  1664. { "PowerBook4,1", "iBook 2",
  1665. PMAC_TYPE_IBOOK2, pangea_features,
  1666. PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
  1667. },
  1668. { "PowerMac1,1", "Blue&White G3",
  1669. PMAC_TYPE_YOSEMITE, paddington_features,
  1670. 0
  1671. },
  1672. { "PowerMac1,2", "PowerMac G4 PCI Graphics",
  1673. PMAC_TYPE_YIKES, paddington_features,
  1674. 0
  1675. },
  1676. { "PowerBook2,1", "iBook (first generation)",
  1677. PMAC_TYPE_ORIG_IBOOK, core99_features,
  1678. PMAC_MB_CAN_SLEEP
  1679. },
  1680. { "PowerMac3,1", "PowerMac G4 AGP Graphics",
  1681. PMAC_TYPE_SAWTOOTH, core99_features,
  1682. 0
  1683. },
  1684. { "PowerMac3,2", "PowerMac G4 AGP Graphics",
  1685. PMAC_TYPE_SAWTOOTH, core99_features,
  1686. 0
  1687. },
  1688. { "PowerMac3,3", "PowerMac G4 AGP Graphics",
  1689. PMAC_TYPE_SAWTOOTH, core99_features,
  1690. 0
  1691. },
  1692. { "PowerMac2,1", "iMac FireWire",
  1693. PMAC_TYPE_FW_IMAC, core99_features,
  1694. PMAC_MB_CAN_SLEEP
  1695. },
  1696. { "PowerMac2,2", "iMac FireWire",
  1697. PMAC_TYPE_FW_IMAC, core99_features,
  1698. PMAC_MB_CAN_SLEEP
  1699. },
  1700. { "PowerBook2,2", "iBook FireWire",
  1701. PMAC_TYPE_FW_IBOOK, core99_features,
  1702. PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
  1703. },
  1704. { "PowerMac5,1", "PowerMac G4 Cube",
  1705. PMAC_TYPE_CUBE, core99_features,
  1706. },
  1707. { "PowerMac3,4", "PowerMac G4 Silver",
  1708. PMAC_TYPE_QUICKSILVER, core99_features,
  1709. 0
  1710. },
  1711. { "PowerMac3,5", "PowerMac G4 Silver",
  1712. PMAC_TYPE_QUICKSILVER, core99_features,
  1713. 0
  1714. },
  1715. { "PowerBook3,1", "PowerBook Pismo",
  1716. PMAC_TYPE_PISMO, core99_features,
  1717. PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
  1718. },
  1719. { "PowerBook3,2", "PowerBook Titanium",
  1720. PMAC_TYPE_TITANIUM, core99_features,
  1721. PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
  1722. },
  1723. { "PowerBook3,3", "PowerBook Titanium II",
  1724. PMAC_TYPE_TITANIUM2, core99_features,
  1725. PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
  1726. },
  1727. };
  1729. /*
  1730.  * The toplevel feature_call callback
  1731.  */
  1732. int __pmac
  1733. pmac_do_feature_call(unsigned int selector, ...)
  1734. {
  1735. struct device_node* node;
  1736. int param, value, i;
  1737. feature_call func = NULL;
  1738. va_list args;
  1740. if (!pmac_mb.features)
  1741. return -ENODEV;
  1742. for (i=0; pmac_mb.features[i].function; i++)
  1743. if (pmac_mb.features[i].selector == selector) {
  1744. func = pmac_mb.features[i].function;
  1745. break;
  1746. }
  1747. if (!func)
  1748. for (i=0; any_features[i].function; i++)
  1749. if (any_features[i].selector == selector) {
  1750. func = any_features[i].function;
  1751. break;
  1752. }
  1753. if (!func)
  1754. return -ENODEV;
  1756. va_start(args, selector);
  1757. node = (struct device_node*)va_arg(args, void*);
  1758. param = va_arg(args, int);
  1759. value = va_arg(args, int);
  1760. va_end(args);
  1762. return func(node, param, value);
  1763. }
  1765. static int __init
  1766. probe_motherboard(void)
  1767. {
  1768. int i;
  1769. struct macio_chip* macio = &macio_chips[0];
  1771. /* Lookup known motherboard type in device-tree */
  1772. for(i=0; i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
  1773.     if (machine_is_compatible(pmac_mb_defs[i].model_string)) {
  1774. pmac_mb = pmac_mb_defs[i];
  1775. goto found;
  1776.     }
  1777. }
  1779. /* Fallback to selection depending on mac-io chip type */
  1780. switch(macio->type) {
  1781.     case macio_grand_central:
  1782. pmac_mb.model_id = PMAC_TYPE_PSURGE;
  1783. pmac_mb.model_name = "Unknown PowerSurge";
  1784. break;
  1785.     case macio_ohare:
  1786. pmac_mb.model_id = PMAC_TYPE_UNKNOWN_OHARE;
  1787. pmac_mb.model_name = "Unknown OHare-based";
  1788.      break;
  1789.     case macio_heathrow:
  1790. pmac_mb.model_id = PMAC_TYPE_UNKNOWN_HEATHROW;
  1791. pmac_mb.model_name = "Unknown Heathrow-based";
  1792. pmac_mb.features = heathrow_desktop_features;
  1793. break;
  1794.     case macio_paddington:
  1795. pmac_mb.model_id = PMAC_TYPE_UNKNOWN_PADDINGTON;
  1796. pmac_mb.model_name = "Unknown Paddington-based";
  1797.      pmac_mb.features = paddington_features;
  1798. break;
  1799.     case macio_keylargo:
  1800. pmac_mb.model_id = PMAC_TYPE_UNKNOWN_CORE99;
  1801. pmac_mb.model_name = "Unknown Keylargo-based";
  1802.      pmac_mb.features = core99_features;
  1803. break;
  1804.     case macio_pangea:
  1805. pmac_mb.model_id = PMAC_TYPE_UNKNOWN_PANGEA;
  1806. pmac_mb.model_name = "Unknown Pangea-based";
  1807.      pmac_mb.features = pangea_features;
  1808. break;
  1809.     default:
  1810.      return -ENODEV;
  1811. }
  1812. found:
  1813. /* Fixup Hooper vs. Comet */
  1814. if (pmac_mb.model_id == PMAC_TYPE_HOOPER) {
  1815. u32* mach_id_ptr = (u32*)ioremap(0xf3000034, 4);
  1816. if (!mach_id_ptr)
  1817. return -ENODEV;
  1818. /* Here, I used to disable the media-bay on comet. It
  1819.  * appears this is wrong, the floppy connector is actually
  1820.  * a kind of media-bay and works with the current driver.
  1821.  */
  1822. if ((*mach_id_ptr) & 0x20000000UL)
  1823. pmac_mb.model_id = PMAC_TYPE_COMET;
  1824. iounmap(mach_id_ptr);
  1825. }
  1827. /* Set default value of powersave_nap on machines that support it.
  1828.  * It appears that uninorth rev 3 has a problem with it, we don't
  1829.  * enable it on those. In theory, the flush-on-lock property is
  1830.  * supposed to be set when not supported, but I'm not very confident
  1831.  * that all Apple OF revs did it properly, I do it the paranoid way.
  1832.  */
  1833. while (uninorth_base && uninorth_rev > 3) {
  1834. struct device_node* np = find_path_device("/cpus");
  1835. u32 pvr = mfspr(PVR);
  1836. if (!np || !np->child) {
  1837. printk(KERN_WARNING "Can't find CPU(s) in device tree !n");
  1838. break;
  1839. }
  1840. np = np->child;
  1841. /* Nap mode not supported on SMP */
  1842. if (np->sibling)
  1843. break;
  1844. /* Nap mode not supported if flush-on-lock property is present */
  1845. if (get_property(np, "flush-on-lock", NULL))
  1846. break;
  1847. /* Some 7450 may have problem with NAP mode too ... */
  1848. if (((pvr >> 16) == 0x8000) && ((pvr & 0xffff) < 0x0201))
  1849. break;
  1850. powersave_nap = 1;
  1851. printk(KERN_INFO "Processor NAP mode on idle enabled.n");
  1852. break;
  1853. }
  1855. printk(KERN_INFO "PowerMac motherboard: %sn", pmac_mb.model_name);
  1856. return 0;
  1857. }
  1859. /* Initialize the Core99 UniNorth host bridge and memory controller
  1860.  */
  1861. static void __init
  1862. probe_uninorth(void)
  1863. {
  1864. unsigned long actrl;
  1866. /* Locate core99 Uni-N */
  1867. uninorth_node = find_devices("uni-n");
  1868. if (uninorth_node && uninorth_node->n_addrs > 0) {
  1869. uninorth_base = ioremap(uninorth_node->addrs[0].address, 0x1000);
  1870. uninorth_rev = in_be32(UN_REG(UNI_N_VERSION));
  1871. } else
  1872. uninorth_node = NULL;
  1874. if (!uninorth_node)
  1875. return;
  1877. printk(KERN_INFO "Found Uninorth memory controller & host bridge, revision: %dn",
  1878. uninorth_rev);
  1880. /* Set the arbitrer QAck delay according to what Apple does
  1881.  */
  1882. if (uninorth_rev < 0x10) {
  1883. actrl = UN_IN(UNI_N_ARB_CTRL) & ~UNI_N_ARB_CTRL_QACK_DELAY_MASK;
  1884. actrl |= ((uninorth_rev < 3) ? UNI_N_ARB_CTRL_QACK_DELAY105 :
  1885. UNI_N_ARB_CTRL_QACK_DELAY) << UNI_N_ARB_CTRL_QACK_DELAY_SHIFT;
  1886. UN_OUT(UNI_N_ARB_CTRL, actrl);
  1887. }
  1888. }
  1890. static void __init
  1891. probe_one_macio(const char* name, const char* compat, int type)
  1892. {
  1893. struct device_node* node;
  1894. int i;
  1895. volatile u32* base;
  1896. u32* revp;
  1898. node = find_devices(name);
  1899. if (!node || !node->n_addrs)
  1900. return;
  1901. if (compat)
  1902. do {
  1903. if (device_is_compatible(node, compat))
  1904. break;
  1905. node = node->next;
  1906. } while (node);
  1907. if (!node)
  1908. return;
  1909. for(i=0; i<MAX_MACIO_CHIPS; i++) {
  1910. if (!macio_chips[i].of_node)
  1911. break;
  1912. if (macio_chips[i].of_node == node)
  1913. return;
  1914. }
  1915. if (i >= MAX_MACIO_CHIPS) {
  1916. printk(KERN_ERR "pmac_feature: Please increase MAX_MACIO_CHIPS !n");
  1917. printk(KERN_ERR "pmac_feature: %s skippedn", node->full_name);
  1918. return;
  1919. }
  1920. base = (volatile u32*)ioremap(node->addrs[0].address, node->addrs[0].size);
  1921. if (!base) {
  1922. printk(KERN_ERR "pmac_feature: Can't map mac-io chip !n");
  1923. return;
  1924. }
  1925. if (type == macio_keylargo) {
  1926. u32* did = (u32 *)get_property(node, "device-id", NULL);
  1927. if (*did == 0x00000025)
  1928. type = macio_pangea;
  1929. }
  1930. macio_chips[i].of_node = node;
  1931. macio_chips[i].type = type;
  1932. macio_chips[i].base = base;
  1933. macio_chips[i].flags = MACIO_FLAG_SCCB_ON | MACIO_FLAG_SCCB_ON;
  1934. revp = (u32 *)get_property(node, "revision-id", NULL);
  1935. if (revp)
  1936. macio_chips[i].rev = *revp;
  1937. printk(KERN_INFO "Found a %s mac-io controller, rev: %d, mapped at 0x%pn",
  1938. macio_names[type], macio_chips[i].rev, macio_chips[i].base);
  1939. }
  1941. static int __init
  1942. probe_macios(void)
  1943. {
  1944. /* Warning, ordering is important */
  1945. probe_one_macio("gc", NULL, macio_grand_central);
  1946. probe_one_macio("ohare", NULL, macio_ohare);
  1947. probe_one_macio("pci106b,7", NULL, macio_ohareII);
  1948. probe_one_macio("mac-io", "keylargo", macio_keylargo);
  1949. probe_one_macio("mac-io", "paddington", macio_paddington);
  1950. probe_one_macio("mac-io", "gatwick", macio_gatwick);
  1951. probe_one_macio("mac-io", "heathrow", macio_heathrow);
  1953. /* Make sure the "main" macio chip appear first */
  1954. if (macio_chips[0].type == macio_gatwick
  1955.     && macio_chips[1].type == macio_heathrow) {
  1956. struct macio_chip temp = macio_chips[0];
  1957. macio_chips[0] = macio_chips[1];
  1958. macio_chips[1] = temp;
  1959. }
  1960. if (macio_chips[0].type == macio_ohareII
  1961.     && macio_chips[1].type == macio_ohare) {
  1962. struct macio_chip temp = macio_chips[0];
  1963. macio_chips[0] = macio_chips[1];
  1964. macio_chips[1] = temp;
  1965. }
  1967. return (macio_chips[0].of_node == NULL) ? -ENODEV : 0;
  1968. }
  1970. static void __init
  1971. initial_serial_shutdown(struct device_node* np)
  1972. {
  1973. int len;
  1974. struct slot_names_prop {
  1975. int count;
  1976. char name[1];
  1977. } *slots;
  1978. char *conn;
  1979. int port_type = PMAC_SCC_ASYNC;
  1980. int modem = 0;
  1982. slots = (struct slot_names_prop *)get_property(np, "slot-names", &len);
  1983. conn = get_property(np, "AAPL,connector", &len);
  1984. if (conn && (strcmp(conn, "infrared") == 0))
  1985. port_type = PMAC_SCC_IRDA;
  1986. else if (device_is_compatible(np, "cobalt"))
  1987. modem = 1;
  1988. else if (slots && slots->count > 0) {
  1989. if (strcmp(slots->name, "IrDA") == 0)
  1990. port_type = PMAC_SCC_IRDA;
  1991. else if (strcmp(slots->name, "Modem") == 0)
  1992. modem = 1;
  1993. }
  1994. if (modem)
  1995. pmac_call_feature(PMAC_FTR_MODEM_ENABLE, np, 0, 0);
  1996. pmac_call_feature(PMAC_FTR_SCC_ENABLE, np, port_type, 0);
  1997. }
  1999. static void __init
  2000. set_initial_features(void)
  2001. {
  2002. struct device_node* np;
  2004. /* That hack appears to be necessary for some StarMax motherboards
  2005.  * but I'm not too sure it was audited for side-effects on other
  2006.  * ohare based machines...
  2007.  * Since I still have difficulties figuring the right way to
  2008.  * differenciate them all and since that hack was there for a long
  2009.  * time, I'll keep it around
  2010.  */
  2011. if (macio_chips[0].type == macio_ohare && !find_devices("via-pmu")) {
  2012. struct macio_chip* macio = &macio_chips[0];
  2013. MACIO_OUT32(OHARE_FCR, STARMAX_FEATURES);
  2014. } else if (macio_chips[0].type == macio_ohare) {
  2015. struct macio_chip* macio = &macio_chips[0];
  2016. MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
  2017. } else if (macio_chips[1].type == macio_ohare) {
  2018. struct macio_chip* macio = &macio_chips[1];
  2019. MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
  2020. }
  2022. if (macio_chips[0].type == macio_keylargo ||
  2023.     macio_chips[0].type == macio_pangea) {
  2024. /* Enable GMAC for now for PCI probing. It will be disabled
  2025.  * later on after PCI probe
  2026.  */
  2027. np = find_devices("ethernet");
  2028. while(np) {
  2029. if (np->parent
  2030.     && device_is_compatible(np->parent, "uni-north")
  2031.     && device_is_compatible(np, "gmac"))
  2032. core99_gmac_enable(np, 0, 1);
  2033. np = np->next;
  2034. }
  2036. /* Enable FW before PCI probe. Will be disabled later on
  2037.  * Note: We should have a batter way to check that we are
  2038.  * dealing with uninorth internal cell and not a PCI cell
  2039.  * on the external PCI. The code below works though.
  2040.  */
  2041. np = find_devices("firewire");
  2042. while(np) {
  2043. if (np->parent
  2044.     && device_is_compatible(np->parent, "uni-north")
  2045.     && (device_is_compatible(np, "pci106b,18") || 
  2046.               device_is_compatible(np, "pci106b,30") ||
  2047.               device_is_compatible(np, "pci11c1,5811"))) {
  2048. macio_chips[0].flags |= MACIO_FLAG_FW_SUPPORTED;
  2049. core99_firewire_enable(np, 0, 1);
  2050. }
  2051. np = np->next;
  2052. }
  2054. /* Switch airport off */
  2055. np = find_devices("radio");
  2056. while(np) {
  2057. if (np && np->parent == macio_chips[0].of_node) {
  2058. macio_chips[0].flags |= MACIO_FLAG_AIRPORT_ON;
  2059. core99_airport_enable(np, 0, 0);
  2060. }
  2061. np = np->next;
  2062. }
  2063. }
  2065. /* On all machines, switch sound off */
  2066. if (macio_chips[0].of_node)
  2067. pmac_do_feature_call(PMAC_FTR_SOUND_CHIP_ENABLE,
  2068. macio_chips[0].of_node, 0, 0);
  2070. /* On all machines, switch modem & serial ports off */
  2071. np = find_devices("ch-a");
  2072. while(np) {
  2073. initial_serial_shutdown(np);
  2074. np = np->next;
  2075. }
  2076. np = find_devices("ch-b");
  2077. while(np) {
  2078. initial_serial_shutdown(np);
  2079. np = np->next;
  2080. }
  2082. /* Let hardware settle down */
  2083. mdelay(10);
  2084. }
  2086. void __init
  2087. pmac_feature_init(void)
  2088. {
  2089. /* Detect the UniNorth memory controller */
  2090. probe_uninorth();
  2092. /* Probe mac-io controllers */
  2093. if (probe_macios()) {
  2094. printk(KERN_WARNING "No mac-io chip foundn");
  2095. return;
  2096. }
  2098. /* Probe machine type */
  2099. if (probe_motherboard())
  2100. printk(KERN_WARNING "Unknown PowerMac !n");
  2102. /* Set some initial features (turn off some chips that will
  2103.  * be later turned on)
  2104.  */
  2105. set_initial_features();
  2106. }
  2108. void __init
  2109. pmac_feature_late_init(void)
  2110. {
  2111. struct device_node* np;
  2113. /* Request some resources late */
  2114. if (uninorth_node)
  2115. request_OF_resource(uninorth_node, 0, NULL);
  2116. np = find_devices("hammerhead");
  2117. if (np)
  2118. request_OF_resource(np, 0, NULL);
  2119. np = find_devices("interrupt-controller");
  2120. if (np)
  2121. request_OF_resource(np, 0, NULL);
  2122. }