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

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

Linux/Unix编程

开发平台：

Unix_Linux

memory.c：源码内容
  1. /* Memory.c - Memory mappings and remapping functions */
  3. /* Copyright - Galileo technology. */
  5. /*
  6. DESCRIPTION
  7. This file contains function which gives the user the ability to remap the
  8. SDRAM memory and devices windows, please pay attention to overlapping windows
  9. since the function do not take care of that for you.
  10. When remapping the SDRAM or devices memory space pay attention to the PCI
  11. mappings and make sure to coordinate between the two interfaces!!!
  12. */
  14. /* includes */
  16. #ifdef __linux__
  17. #include <asm/galileo-boards/evb64120A/core.h>
  18. #include <asm/galileo-boards/evb64120A/memory.h>
  19. #else
  20. #include "Core.h"
  21. #include "Memory.h"
  22. #endif
  24. /********************************************************************
  25. * getMemoryBankBaseAddress - Extract the base address of a memory bank
  26. *      - If the memory bank size is 0 then this base address has no meaning !!!
  27. *
  28. * INPUTS:  MEMORY_BANK bank - SDRAM Bank number.
  29. * OUTPUT:  N/A
  30. * RETURNS: Memory bank base address.
  31. *********************************************************************/
  32. unsigned int getMemoryBankBaseAddress(MEMORY_BANK bank)
  33. {
  34. unsigned int base, regBase;
  35. GT_REG_READ((SCS_1_0_LOW_DECODE_ADDRESS + (bank / 2) * 0x10),
  36.     &base);
  37. base = base << 21;
  38. GT_REG_READ((SCS_0_LOW_DECODE_ADDRESS + bank * 8), &regBase);
  39. base = base | (regBase << 20);
  40. return base;
  41. }
  43. /********************************************************************
  44. * getDeviceBaseAddress - Extract the base address of a device.
  45. *           - If the device size is 0 then this base address has no meaning!!!
  46. *
  47. * INPUT:   DEVICE device - Bank number.
  48. * OUTPUT:  N/A
  49. * RETURNS: Device base address.
  50. *********************************************************************/
  51. unsigned int getDeviceBaseAddress(DEVICE device)
  52. {
  53. unsigned int base, regBase;
  54. GT_REG_READ((CS_2_0_LOW_DECODE_ADDRESS + (device / 3) * 0x10),
  55.     &base);
  56. base = base << 21;
  57. GT_REG_READ((CS_0_LOW_DECODE_ADDRESS + device * 0x8), &regBase);
  58. base = base | (regBase << 20);
  59. return base;
  60. }
  62. /********************************************************************
  63. * getMemoryBankSize - Extract the size of a memory bank.
  64. *
  65. * INPUT:   MEMORY_BANK bank - Bank number
  66. * OUTPUT:  N/A
  67. * RETURNS: Memory bank size.
  68. *********************************************************************/
  69. unsigned int getMemoryBankSize(MEMORY_BANK bank)
  70. {
  71. unsigned int size, base, value;
  72. base = getMemoryBankBaseAddress(bank);
  73. GT_REG_READ((SCS_0_HIGH_DECODE_ADDRESS + bank * 8), &size);
  74. size = ((size + 1) << 20) - (base & 0x0fffffff);
  75. GT_REG_READ((SCS_0_HIGH_DECODE_ADDRESS + bank * 8), &value);
  76. if (value == 0)
  77. return 0;
  78. else
  79. return size;
  80. }
  82. /********************************************************************
  83. * getDeviceSize - Extract the size of a device memory space
  84. *
  85. * INPUT:    DEVICE device - Device number
  86. * OUTPUT:   N/A
  87. * RETURNS:  Size of a device memory space.
  88. *********************************************************************/
  89. unsigned int getDeviceSize(DEVICE device)
  90. {
  91. unsigned int size, base, value;
  92. base = getDeviceBaseAddress(device);
  93. GT_REG_READ((CS_0_HIGH_DECODE_ADDRESS + device * 8), &size);
  94. size = ((size + 1) << 20) - (base & 0x0fffffff);
  95. GT_REG_READ((CS_0_HIGH_DECODE_ADDRESS + device * 8), &value);
  96. if ((value + 1) == 0)
  97. return 0;
  98. else
  99. return size;
  100. }
  102. /********************************************************************
  103. * getDeviceWidth - A device can be with: 1,2,4 or 8 Bytes data width.
  104. *                  The width is determine in registers: 'Device Parameters'
  105. *                  registers (0x45c, 0x460, 0x464, 0x468, 0x46c - for each device.
  106. *                  at bits: [21:20].
  107. *
  108. * INPUT:    DEVICE device - Device number
  109. * OUTPUT:   N/A
  110. * RETURNS:  Device width in Bytes (1,2,4, or 8), 0 if error had occurred.
  111. *********************************************************************/
  112. unsigned int getDeviceWidth(DEVICE device)
  113. {
  114. unsigned int width;
  115. unsigned int regValue;
  117. GT_REG_READ(DEVICE_BANK0PARAMETERS + device * 4, &regValue);
  118. width = (regValue & 0x00300000) >> 20;
  119. switch (width) {
  120. case 0:
  121. return 1;
  122. case 1:
  123. return 2;
  124. case 2:
  125. return 4;
  126. case 3:
  127. return 8;
  128. default:
  129. return 0;
  130. }
  131. }
  133. /********************************************************************
  134. * mapMemoryBanks0and1 - Sets new bases and boundaries for memory banks 0 and 1
  135. *                     - Pay attention to the PCI mappings and make sure to
  136. *                       coordinate between the two interfaces!!!
  137. *                     - It is the programmer`s responsibility to make sure
  138. *                       there are no conflicts with other memory spaces!!!
  139. *                     - If a bank needs to be closed , give it a 0 length
  140. *
  141. *
  142. * INPUTS: unsigned int bank0Base - required bank 0 base address.
  143. *         unsigned int bank0Length - required bank 0 size.
  144. *         unsigned int bank1Base - required bank 1 base address.
  145. *         unsigned int bank1Length - required bank 1 size.
  146. * RETURNS: true on success, false on failure or if one of the parameters is
  147. *          erroneous.
  148. *********************************************************************/
  149. bool mapMemoryBanks0and1(unsigned int bank0Base, unsigned int bank0Length,
  150.  unsigned int bank1Base, unsigned int bank1Length)
  151. {
  152. unsigned int mainBank0Top = bank0Base + bank0Length;
  153. unsigned int mainBank1Top = bank1Base + bank1Length;
  154. unsigned int memBank0Base, bank0Top;
  155. unsigned int memBank1Base, bank1Top;
  157. if (bank0Base <= bank1Base) {
  158. if ((bank0Base + bank0Length) > bank1Base)
  159. return false;
  160. } else {
  161. if ((bank1Base + bank1Length) > bank0Base)
  162. return false;
  163. }
  165. if (bank0Length == 0)
  166. mainBank0Top++;
  167. if (bank1Length == 0)
  168. mainBank1Top++;
  170. memBank0Base = ((unsigned int) (bank0Base & 0x0fffffff)) >> 20;
  171. bank0Top = ((unsigned int) (mainBank0Top & 0x0fffffff)) >> 20;
  172. memBank1Base = ((unsigned int) (bank1Base & 0x0fffffff)) >> 20;
  173. bank1Top = ((unsigned int) (mainBank1Top & 0x0fffffff)) >> 20;
  175. if (mainBank1Top > mainBank0Top) {
  176. bank0Base >>= 21;
  177. mainBank0Top =
  178.     ((unsigned int) (mainBank1Top & 0x0fffffff)) >> 21;
  179. } else {
  180. bank0Base = bank1Base >> 21;
  181. mainBank0Top =
  182.     ((unsigned int) (mainBank0Top & 0x0fffffff)) >> 21;
  183. }
  184. GT_REG_WRITE(SCS_1_0_LOW_DECODE_ADDRESS, bank0Base);
  185. if ((bank0Length + bank1Length) != 0) {
  186. GT_REG_WRITE(SCS_1_0_HIGH_DECODE_ADDRESS,
  187.      mainBank0Top - 1);
  188. } else {
  189. GT_REG_WRITE(SCS_1_0_HIGH_DECODE_ADDRESS, 0x0);
  190. }
  191. if (bank1Length != 0) {
  192. GT_REG_WRITE(SCS_1_HIGH_DECODE_ADDRESS, bank1Top - 1);
  193. } else {
  194. GT_REG_WRITE(SCS_1_HIGH_DECODE_ADDRESS, 0x0);
  195. }
  196. GT_REG_WRITE(SCS_1_LOW_DECODE_ADDRESS, memBank1Base);
  197. if (bank0Length != 0) {
  198. GT_REG_WRITE(SCS_0_HIGH_DECODE_ADDRESS, bank0Top - 1);
  199. } else {
  200. GT_REG_WRITE(SCS_0_HIGH_DECODE_ADDRESS, 0x0);
  201. }
  202. GT_REG_WRITE(SCS_0_LOW_DECODE_ADDRESS, memBank0Base);
  203. return true;
  204. }
  206. /********************************************************************
  207. * mapMemoryBanks2and3 - Sets new bases and boundaries for memory banks 2 and 3
  208. *                     - Pay attention to the PCI mappings and make sure to
  209. *                       coordinate between the two interfaces!!!
  210. *                     - It`s the programmer`s responsibility to make sure there
  211. *                       are no conflicts with other memory spaces!!!
  212. *                     - If a bank needs to be closed , give it a 0 length.
  213. *
  214. *
  215. * INPUTS: unsigned int bank2Base - required bank 2 base address.
  216. *         unsigned int bank2Length - required bank 2 size.
  217. *         unsigned int bank3Base - required bank 3 base address.
  218. *         unsigned int bank3Length - required bank 3 size.
  219. * RETURNS: true on success, false on failure or if one of the parameters is
  220. *          erroneous.
  221. *********************************************************************/
  222. bool mapMemoryBanks2and3(unsigned int bank2Base, unsigned int bank2Length,
  223.  unsigned int bank3Base, unsigned int bank3Length)
  224. {
  225. unsigned int mainBank2Top =
  226.     (unsigned int) (bank2Base + bank2Length);
  227. unsigned int mainBank3Top =
  228.     (unsigned int) (bank3Base + bank3Length);
  229. unsigned int memBank2Base, bank2Top;
  230. unsigned int memBank3Base, bank3Top;
  232. if (bank2Base <= bank3Base) {
  233. if ((bank2Base + bank2Length) > bank3Base)
  234. return false;
  235. } else {
  236. if ((bank3Base + bank3Length) > bank2Base)
  237. return false;
  238. }
  239. if (bank2Length == 0)
  240. mainBank2Top++;
  241. if (bank3Length == 0)
  242. mainBank3Top++;
  244. memBank2Base = ((unsigned int) (bank2Base & 0x0fffffff)) >> 20;
  245. bank2Top = ((unsigned int) (mainBank2Top & 0x0fffffff)) >> 20;
  246. memBank3Base = ((unsigned int) (bank3Base & 0x0fffffff)) >> 20;
  247. bank3Top = ((unsigned int) (mainBank3Top & 0x0fffffff)) >> 20;
  249. if (mainBank3Top > mainBank2Top) {
  250. bank2Base >>= 21;
  251. mainBank2Top =
  252.     ((unsigned int) (mainBank3Top & 0x0fffffff)) >> 21;
  253. } else {
  254. bank2Base = bank3Base >> 21;
  255. mainBank2Top =
  256.     ((unsigned int) (mainBank2Top & 0x0fffffff)) >> 21;
  257. }
  258. GT_REG_WRITE(SCS_3_2_LOW_DECODE_ADDRESS, bank2Base);
  259. if ((bank2Length + bank3Length) != 0) {
  260. GT_REG_WRITE(SCS_3_2_HIGH_DECODE_ADDRESS,
  261.      mainBank2Top - 1);
  262. } else {
  263. GT_REG_WRITE(SCS_3_2_HIGH_DECODE_ADDRESS, 0x0);
  264. }
  265. if (bank3Length != 0) {
  266. GT_REG_WRITE(SCS_3_HIGH_DECODE_ADDRESS, bank3Top - 1);
  267. } else {
  268. GT_REG_WRITE(SCS_3_HIGH_DECODE_ADDRESS, 0x0);
  269. }
  270. GT_REG_WRITE(SCS_3_LOW_DECODE_ADDRESS, memBank3Base);
  271. if (bank2Length != 0) {
  272. GT_REG_WRITE(SCS_2_HIGH_DECODE_ADDRESS, bank2Top - 1);
  273. } else {
  274. GT_REG_WRITE(SCS_2_HIGH_DECODE_ADDRESS, 0x0);
  275. }
  276. GT_REG_WRITE(SCS_2_LOW_DECODE_ADDRESS, memBank2Base);
  277. return true;
  278. }
  280. /********************************************************************
  281. * mapDevices0_1and2MemorySpace - Sets new bases and boundaries for devices 0,1
  282. *                                and 2
  283. *                     - Pay attention to the PCI mappings and make sure to
  284. *                        coordinate between the two interfaces!!!
  285. *                     - It`s the programmer`s responsibility to make sure there
  286. *                       are no conflicts with other memory spaces!!!
  287. *                     - If a device needs to be closed , give it a 0 length
  288. *
  289. *
  290. * INPUTS: unsigned int device0Base - required cs_0 base address.
  291. *         unsigned int device0Length - required cs_0 size.
  292. *         unsigned int device1Base - required cs_1 base address.
  293. *         unsigned int device1Length - required cs_0 size.
  294. *         unsigned int device2Base - required cs_2 base address.
  295. *         unsigned int device2Length - required cs_2 size.
  296. * RETURNS: true on success, false on failure or if one of the parameters is
  297. *          erroneous.
  298. *********************************************************************/
  299. bool mapDevices0_1and2MemorySpace(unsigned int device0Base,
  300.   unsigned int device0Length,
  301.   unsigned int device1Base,
  302.   unsigned int device1Length,
  303.   unsigned int device2Base,
  304.   unsigned int device2Length)
  305. {
  306. unsigned int deviceBank0Top =
  307.     (unsigned int) (device0Base + device0Length);
  308. unsigned int deviceBank1Top =
  309.     (unsigned int) (device1Base + device1Length);
  310. unsigned int deviceBank2Top =
  311.     (unsigned int) (device2Base + device2Length);
  312. unsigned int device0BaseTemp = 0, device0TopTemp = 0;
  313. unsigned int bank0Base, bank0Top;
  314. unsigned int bank1Base, bank1Top;
  315. unsigned int bank2Base, bank2Top;
  316. bank0Base = ((unsigned int) (device0Base & 0x0fffffff)) >> 20;
  317. bank0Top = ((unsigned int) (deviceBank0Top & 0x0fffffff)) >> 20;
  318. bank1Base = ((unsigned int) (device1Base & 0x0fffffff)) >> 20;
  319. bank1Top = ((unsigned int) (deviceBank1Top & 0x0fffffff)) >> 20;
  320. bank2Base = ((unsigned int) (device2Base & 0x0fffffff)) >> 20;
  321. bank2Top = ((unsigned int) (deviceBank2Top & 0x0fffffff)) >> 20;
  323. if (device0Length == 0)
  324. deviceBank0Top++;
  325. if (device1Length == 0)
  326. deviceBank1Top++;
  327. if (device2Length == 0)
  328. deviceBank2Top++;
  330. if (device0Base <= device1Base && device0Base <= device2Base) {
  331. if ((device0Base + device0Length) > device1Base || 
  332.     (device0Base + device0Length) > device2Base)
  333. return false;
  334. if (device1Base <= device2Base) {
  335. if ((device1Base + device1Length) > device2Base)
  336. return false;
  337. } else {
  338. if ((device2Base + device2Length) > device1Base)
  339. return false;
  340. }
  341. }
  343. if (device1Base <= device0Base && device1Base <= device2Base) {
  344. if ((device1Base + device1Length) > device0Base ||
  345.     (device1Base + device1Length) > device2Base)
  346. return false;
  347. if (device0Base <= device2Base) {
  348. if ((device0Base + device0Length) > device2Base)
  349. return false;
  350. } else {
  351. if ((device2Base + device2Length) > device0Base)
  352. return false;
  353. }
  354. }
  356. if (device2Base <= device1Base && device2Base <= device0Base) {
  357. if ((device2Base + device2Length) > device1Base ||
  358.     (device2Base + device2Length) > device0Base)
  359. return false;
  360. if (device0Base <= device1Base) {
  361. if ((device0Base + device0Length) > device1Base)
  362. return false;
  363. } else {
  364. if ((device1Base + device1Length) > device0Base)
  365. return false;
  366. }
  367. }
  369. if ((deviceBank2Top > deviceBank1Top) && (deviceBank1Top >
  370.   deviceBank0Top)) {
  371. device0BaseTemp = device0Base >> 21;
  372. device0TopTemp =
  373.     ((unsigned int) (deviceBank2Top & 0x0fffffff)) >> 21;
  374. }
  375. if ((deviceBank2Top > deviceBank0Top)
  376.     && (deviceBank0Top > deviceBank1Top)) {
  377. device0BaseTemp = device1Base >> 21;
  378. device0TopTemp =
  379.     ((unsigned int) (deviceBank2Top & 0x0fffffff)) >> 21;
  380. }
  381. if ((deviceBank1Top > deviceBank2Top)
  382.     && (deviceBank2Top > deviceBank0Top)) {
  383. device0BaseTemp = device0Base >> 21;
  384. device0TopTemp =
  385.     ((unsigned int) (deviceBank1Top & 0x0fffffff)) >> 21;
  386. }
  387. if ((deviceBank1Top > deviceBank0Top)
  388.     && (deviceBank0Top > deviceBank2Top)) {
  389. device0BaseTemp = device2Base >> 21;
  390. device0TopTemp =
  391.     ((unsigned int) (deviceBank1Top & 0x0fffffff)) >> 21;
  392. }
  393. if ((deviceBank0Top > deviceBank2Top)
  394.     && (deviceBank2Top > deviceBank1Top)) {
  395. device0BaseTemp = device1Base >> 21;
  396. device0TopTemp =
  397.     ((unsigned int) (deviceBank0Top & 0x0fffffff)) >> 21;
  398. }
  399. if ((deviceBank0Top > deviceBank1Top)
  400.     && (deviceBank1Top > deviceBank2Top)) {
  401. device0BaseTemp = device2Base >> 21;
  402. device0TopTemp =
  403.     ((unsigned int) (deviceBank0Top & 0x0fffffff)) >> 21;
  404. }
  405. GT_REG_WRITE(CS_2_0_LOW_DECODE_ADDRESS, device0BaseTemp);
  406. if ((device0Length + device1Length + device2Length) != 0) {
  407. GT_REG_WRITE(CS_2_0_HIGH_DECODE_ADDRESS,
  408.      device0TopTemp - 1);
  409. } else {
  410. GT_REG_WRITE(CS_2_0_HIGH_DECODE_ADDRESS, 0x0);
  411. }
  412. GT_REG_WRITE(CS_0_LOW_DECODE_ADDRESS, bank0Base);
  413. if (device0Length != 0) {
  414. GT_REG_WRITE(CS_0_HIGH_DECODE_ADDRESS, bank0Top - 1);
  415. } else {
  416. GT_REG_WRITE(CS_0_HIGH_DECODE_ADDRESS, 0x0);
  417. }
  418. GT_REG_WRITE(CS_1_LOW_DECODE_ADDRESS, bank1Base);
  419. if (device1Length != 0) {
  420. GT_REG_WRITE(CS_1_HIGH_DECODE_ADDRESS, bank1Top - 1);
  421. } else {
  422. GT_REG_WRITE(CS_1_HIGH_DECODE_ADDRESS, 0x0);
  423. }
  424. GT_REG_WRITE(CS_2_LOW_DECODE_ADDRESS, bank2Base);
  425. if (device2Length != 0) {
  426. GT_REG_WRITE(CS_2_HIGH_DECODE_ADDRESS, bank2Top - 1);
  427. } else {
  428. GT_REG_WRITE(CS_2_HIGH_DECODE_ADDRESS, 0x0);
  429. }
  430. return true;
  431. }
  433. /********************************************************************
  434. * mapDevices3andBootMemorySpace - Sets new bases and boundaries for devices:
  435. *                                 3 and boot
  436. *                     - Pay attention to the PCI mappings and make sure to
  437. *                       coordinate between the two interfaces!!!
  438. *                     - It is the programmer`s responsibility to make sure
  439. *                       there are no conflicts with other memory spaces!!!
  440. *                     - If a device needs to be closed , give it a 0 length.
  441. *
  442. * INPUTS: base and length of device 3and boot
  443. * RETURNS: true on success, false on failure
  444. *********************************************************************/
  445. bool mapDevices3andBootMemorySpace(unsigned int device3Base,
  446.    unsigned int device3Length,
  447.    unsigned int bootDeviceBase,
  448.    unsigned int bootDeviceLength)
  449. {
  450. unsigned int deviceBank3Top =
  451.     (unsigned int) (device3Base + device3Length);
  452. unsigned int deviceBankBootTop =
  453.     (unsigned int) (bootDeviceBase + bootDeviceLength);
  454. unsigned int bank3Base, bank3Top;
  455. unsigned int bank4Base, bank4Top;
  456. unsigned int Device1Base, Device1Top;
  458. bank3Top = ((unsigned int) (deviceBank3Top & 0x0fffffff)) >> 20;
  459. bank4Top = ((unsigned int) (deviceBankBootTop & 0x0fffffff)) >> 20;
  460. bank3Base = ((unsigned int) (device3Base & 0x0fffffff)) >> 20;
  461. bank4Base = ((unsigned int) (bootDeviceBase & 0x0fffffff)) >> 20;
  463. if (device3Base <= bootDeviceBase) {
  464. if (deviceBank3Top > bootDeviceBase)
  465. return false;
  466. } else {
  467. if (deviceBankBootTop > device3Base)
  468. return false;
  469. }
  471. if (deviceBankBootTop > deviceBank3Top) {
  472. Device1Base = device3Base >> 21;
  473. Device1Top =
  474.     ((unsigned int) (deviceBankBootTop & 0x0fffffff)) >>
  475.     21;
  476. } else {
  477. Device1Base = bootDeviceBase >> 21;
  478. Device1Top =
  479.     ((unsigned int) (deviceBank3Top & 0x0fffffff)) >> 21;
  480. }
  481. GT_REG_WRITE(CS_3_BOOTCS_LOW_DECODE_ADDRESS, Device1Base);
  482. if ((device3Length + bootDeviceLength) != 0) {
  483. GT_REG_WRITE(CS_3_BOOTCS_HIGH_DECODE_ADDRESS,
  484.      Device1Top - 1);
  485. } else {
  486. GT_REG_WRITE(CS_3_BOOTCS_HIGH_DECODE_ADDRESS, 0x0);
  487. }
  488. GT_REG_WRITE(CS_3_LOW_DECODE_ADDRESS, bank3Base);
  489. if (device3Length != 0) {
  490. GT_REG_WRITE(CS_3_HIGH_DECODE_ADDRESS, bank3Top - 1);
  491. } else {
  492. GT_REG_WRITE(CS_3_HIGH_DECODE_ADDRESS, 0x0);
  493. }
  494. GT_REG_WRITE(BOOTCS_LOW_DECODE_ADDRESS, bank4Base);
  495. if (bootDeviceLength != 0) {
  496. GT_REG_WRITE(BOOTCS_HIGH_DECODE_ADDRESS, bank4Top - 1);
  497. } else {
  498. GT_REG_WRITE(BOOTCS_HIGH_DECODE_ADDRESS, 0x0);
  499. }
  500. return true;
  501. }
  503. /********************************************************************
  504. * modifyDeviceParameters - This function can be used to modify a device`s
  505. *                          parameters.
  506. *                        - Be advised to check the spec before modifying them.
  507. * Inputs:
  508. * Returns: false if one of the parameters is erroneous,true otherwise.
  509. *********************************************************************/
  510. bool modifyDeviceParameters(DEVICE device, unsigned int turnOff,
  511.     unsigned int accToFirst,
  512.     unsigned int accToNext, unsigned int aleToWr,
  513.     unsigned int wrActive, unsigned int wrHigh,
  514.     unsigned int width, bool paritySupport)
  515. {
  516. unsigned int data, oldValue;
  518. if ((turnOff > 0x7 && turnOff != DONT_MODIFY)
  519.     || (accToFirst > 0xf && accToFirst != DONT_MODIFY)
  520.     || (accToNext > 0xf && accToNext != DONT_MODIFY)
  521.     || (aleToWr > 0x7 && aleToWr != DONT_MODIFY)
  522.     || (wrActive > 0x7 && wrActive != DONT_MODIFY)
  523.     || (wrHigh > 0x7 && wrHigh != DONT_MODIFY)) {
  524. return false;
  525. }
  527. GT_REG_READ((DEVICE_BANK0PARAMETERS + device * 4), &oldValue);
  528. if (turnOff == DONT_MODIFY)
  529. turnOff = oldValue & 0x00000007;
  530. else
  531. turnOff = turnOff;
  533. if (accToFirst == DONT_MODIFY)
  534. accToFirst = oldValue & 0x00000078;
  535. else
  536. accToFirst = accToFirst << 3;
  538. if (accToNext == DONT_MODIFY)
  539. accToNext = oldValue & 0x00000780;
  540. else
  541. accToNext = accToNext << 7;
  543. if (aleToWr == DONT_MODIFY)
  544. aleToWr = oldValue & 0x00003800;
  545. else
  546. aleToWr = aleToWr << 11;
  548. if (wrActive == DONT_MODIFY)
  549. wrActive = oldValue & 0x0001c000;
  550. else
  551. wrActive = wrActive << 14;
  553. if (wrHigh == DONT_MODIFY)
  554. wrHigh = oldValue & 0x000e0000;
  555. else
  556. wrHigh = wrHigh << 17;
  558. data =
  559.     turnOff | accToFirst | accToNext | aleToWr | wrActive | wrHigh;
  560. switch (width) {
  561. case _8BIT:
  562. break;
  563. case _16BIT:
  564. data = data | _16BIT;
  565. break;
  566. case _32BIT:
  567. data = data | _32BIT;
  568. break;
  569. case _64BIT:
  570. data = data | _64BIT;
  571. break;
  572. default:
  573. return false;
  574. }
  575. if (paritySupport == true)
  576. data = data | PARITY_SUPPORT;
  577. GT_REG_WRITE(DEVICE_BANK0PARAMETERS + device * 4, data);
  578. return true;
  579. }
  581. /********************************************************************
  582. * remapAddress - This fubction used for address remapping
  583. * Inputs:      - regOffset: remap register
  584. *                remapHeader : remapped address
  585. * Returns: false if one of the parameters is erroneous,true otherwise.
  586. *********************************************************************/
  587. bool remapAddress(unsigned int remapReg, unsigned int remapValue)
  588. {
  589. unsigned int valueForReg;
  590. valueForReg = (remapValue & 0xffe00000) >> 21;
  591. GT_REG_WRITE(remapReg, valueForReg);
  592. return true;
  593. }