Home Explore Help
Sign In
chaosmonk
/
CHIP-linux-libre
Watch 1
Star 0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Tree: b2c476490d
Branches Tags
CHIP-linux-l...
/
arch
/
alpha
/
lib
/
fpreg.c

fpreg.c 6.0 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194 
  1. /*
    2. 

  2.  * arch/alpha/lib/fpreg.c
    3. 

  3.  *
    4. 

  4.  * (C) Copyright 1998 Linus Torvalds
    5. 

  5.  */
    6. 

  6. 

  7. #if defined(CONFIG_ALPHA_EV6) || defined(CONFIG_ALPHA_EV67)
    8. 

  8. #define STT(reg,val)  asm volatile ("ftoit $f"#reg",%0" : "=r"(val));
    9. 

  9. #else
    10. 

  10. #define STT(reg,val)  asm volatile ("stt $f"#reg",%0" : "=m"(val));
    11. 

  11. #endif
    12. 

  12. 

  13. unsigned long
    14. 

  14. alpha_read_fp_reg (unsigned long reg)
    15. 

  15. {
    16. 

  16. 	unsigned long val;
    17. 

  17. 

  18. 	switch (reg) {
    19. 

  19. 	      case  0: STT( 0, val); break;
    20. 

  20. 	      case  1: STT( 1, val); break;
    21. 

  21. 	      case  2: STT( 2, val); break;
    22. 

  22. 	      case  3: STT( 3, val); break;
    23. 

  23. 	      case  4: STT( 4, val); break;
    24. 

  24. 	      case  5: STT( 5, val); break;
    25. 

  25. 	      case  6: STT( 6, val); break;
    26. 

  26. 	      case  7: STT( 7, val); break;
    27. 

  27. 	      case  8: STT( 8, val); break;
    28. 

  28. 	      case  9: STT( 9, val); break;
    29. 

  29. 	      case 10: STT(10, val); break;
    30. 

  30. 	      case 11: STT(11, val); break;
    31. 

  31. 	      case 12: STT(12, val); break;
    32. 

  32. 	      case 13: STT(13, val); break;
    33. 

  33. 	      case 14: STT(14, val); break;
    34. 

  34. 	      case 15: STT(15, val); break;
    35. 

  35. 	      case 16: STT(16, val); break;
    36. 

  36. 	      case 17: STT(17, val); break;
    37. 

  37. 	      case 18: STT(18, val); break;
    38. 

  38. 	      case 19: STT(19, val); break;
    39. 

  39. 	      case 20: STT(20, val); break;
    40. 

  40. 	      case 21: STT(21, val); break;
    41. 

  41. 	      case 22: STT(22, val); break;
    42. 

  42. 	      case 23: STT(23, val); break;
    43. 

  43. 	      case 24: STT(24, val); break;
    44. 

  44. 	      case 25: STT(25, val); break;
    45. 

  45. 	      case 26: STT(26, val); break;
    46. 

  46. 	      case 27: STT(27, val); break;
    47. 

  47. 	      case 28: STT(28, val); break;
    48. 

  48. 	      case 29: STT(29, val); break;
    49. 

  49. 	      case 30: STT(30, val); break;
    50. 

  50. 	      case 31: STT(31, val); break;
    51. 

  51. 	      default: return 0;
    52. 

  52. 	}
    53. 

  53. 	return val;
    54. 

  54. }
    55. 

  55. 

  56. #if defined(CONFIG_ALPHA_EV6) || defined(CONFIG_ALPHA_EV67)
    57. 

  57. #define LDT(reg,val)  asm volatile ("itoft %0,$f"#reg : : "r"(val));
    58. 

  58. #else
    59. 

  59. #define LDT(reg,val)  asm volatile ("ldt $f"#reg",%0" : : "m"(val));
    60. 

  60. #endif
    61. 

  61. 

  62. void
    63. 

  63. alpha_write_fp_reg (unsigned long reg, unsigned long val)
    64. 

  64. {
    65. 

  65. 	switch (reg) {
    66. 

  66. 	      case  0: LDT( 0, val); break;
    67. 

  67. 	      case  1: LDT( 1, val); break;
    68. 

  68. 	      case  2: LDT( 2, val); break;
    69. 

  69. 	      case  3: LDT( 3, val); break;
    70. 

  70. 	      case  4: LDT( 4, val); break;
    71. 

  71. 	      case  5: LDT( 5, val); break;
    72. 

  72. 	      case  6: LDT( 6, val); break;
    73. 

  73. 	      case  7: LDT( 7, val); break;
    74. 

  74. 	      case  8: LDT( 8, val); break;
    75. 

  75. 	      case  9: LDT( 9, val); break;
    76. 

  76. 	      case 10: LDT(10, val); break;
    77. 

  77. 	      case 11: LDT(11, val); break;
    78. 

  78. 	      case 12: LDT(12, val); break;
    79. 

  79. 	      case 13: LDT(13, val); break;
    80. 

  80. 	      case 14: LDT(14, val); break;
    81. 

  81. 	      case 15: LDT(15, val); break;
    82. 

  82. 	      case 16: LDT(16, val); break;
    83. 

  83. 	      case 17: LDT(17, val); break;
    84. 

  84. 	      case 18: LDT(18, val); break;
    85. 

  85. 	      case 19: LDT(19, val); break;
    86. 

  86. 	      case 20: LDT(20, val); break;
    87. 

  87. 	      case 21: LDT(21, val); break;
    88. 

  88. 	      case 22: LDT(22, val); break;
    89. 

  89. 	      case 23: LDT(23, val); break;
    90. 

  90. 	      case 24: LDT(24, val); break;
    91. 

  91. 	      case 25: LDT(25, val); break;
    92. 

  92. 	      case 26: LDT(26, val); break;
    93. 

  93. 	      case 27: LDT(27, val); break;
    94. 

  94. 	      case 28: LDT(28, val); break;
    95. 

  95. 	      case 29: LDT(29, val); break;
    96. 

  96. 	      case 30: LDT(30, val); break;
    97. 

  97. 	      case 31: LDT(31, val); break;
    98. 

  98. 	}
    99. 

  99. }
    100. 

  100. 

  101. #if defined(CONFIG_ALPHA_EV6) || defined(CONFIG_ALPHA_EV67)
    102. 

  102. #define STS(reg,val)  asm volatile ("ftois $f"#reg",%0" : "=r"(val));
    103. 

  103. #else
    104. 

  104. #define STS(reg,val)  asm volatile ("sts $f"#reg",%0" : "=m"(val));
    105. 

  105. #endif
    106. 

  106. 

  107. unsigned long
    108. 

  108. alpha_read_fp_reg_s (unsigned long reg)
    109. 

  109. {
    110. 

  110. 	unsigned long val;
    111. 

  111. 

  112. 	switch (reg) {
    113. 

  113. 	      case  0: STS( 0, val); break;
    114. 

  114. 	      case  1: STS( 1, val); break;
    115. 

  115. 	      case  2: STS( 2, val); break;
    116. 

  116. 	      case  3: STS( 3, val); break;
    117. 

  117. 	      case  4: STS( 4, val); break;
    118. 

  118. 	      case  5: STS( 5, val); break;
    119. 

  119. 	      case  6: STS( 6, val); break;
    120. 

  120. 	      case  7: STS( 7, val); break;
    121. 

  121. 	      case  8: STS( 8, val); break;
    122. 

  122. 	      case  9: STS( 9, val); break;
    123. 

  123. 	      case 10: STS(10, val); break;
    124. 

  124. 	      case 11: STS(11, val); break;
    125. 

  125. 	      case 12: STS(12, val); break;
    126. 

  126. 	      case 13: STS(13, val); break;
    127. 

  127. 	      case 14: STS(14, val); break;
    128. 

  128. 	      case 15: STS(15, val); break;
    129. 

  129. 	      case 16: STS(16, val); break;
    130. 

  130. 	      case 17: STS(17, val); break;
    131. 

  131. 	      case 18: STS(18, val); break;
    132. 

  132. 	      case 19: STS(19, val); break;
    133. 

  133. 	      case 20: STS(20, val); break;
    134. 

  134. 	      case 21: STS(21, val); break;
    135. 

  135. 	      case 22: STS(22, val); break;
    136. 

  136. 	      case 23: STS(23, val); break;
    137. 

  137. 	      case 24: STS(24, val); break;
    138. 

  138. 	      case 25: STS(25, val); break;
    139. 

  139. 	      case 26: STS(26, val); break;
    140. 

  140. 	      case 27: STS(27, val); break;
    141. 

  141. 	      case 28: STS(28, val); break;
    142. 

  142. 	      case 29: STS(29, val); break;
    143. 

  143. 	      case 30: STS(30, val); break;
    144. 

  144. 	      case 31: STS(31, val); break;
    145. 

  145. 	      default: return 0;
    146. 

  146. 	}
    147. 

  147. 	return val;
    148. 

  148. }
    149. 

  149. 

  150. #if defined(CONFIG_ALPHA_EV6) || defined(CONFIG_ALPHA_EV67)
    151. 

  151. #define LDS(reg,val)  asm volatile ("itofs %0,$f"#reg : : "r"(val));
    152. 

  152. #else
    153. 

  153. #define LDS(reg,val)  asm volatile ("lds $f"#reg",%0" : : "m"(val));
    154. 

  154. #endif
    155. 

  155. 

  156. void
    157. 

  157. alpha_write_fp_reg_s (unsigned long reg, unsigned long val)
    158. 

  158. {
    159. 

  159. 	switch (reg) {
    160. 

  160. 	      case  0: LDS( 0, val); break;
    161. 

  161. 	      case  1: LDS( 1, val); break;
    162. 

  162. 	      case  2: LDS( 2, val); break;
    163. 

  163. 	      case  3: LDS( 3, val); break;
    164. 

  164. 	      case  4: LDS( 4, val); break;
    165. 

  165. 	      case  5: LDS( 5, val); break;
    166. 

  166. 	      case  6: LDS( 6, val); break;
    167. 

  167. 	      case  7: LDS( 7, val); break;
    168. 

  168. 	      case  8: LDS( 8, val); break;
    169. 

  169. 	      case  9: LDS( 9, val); break;
    170. 

  170. 	      case 10: LDS(10, val); break;
    171. 

  171. 	      case 11: LDS(11, val); break;
    172. 

  172. 	      case 12: LDS(12, val); break;
    173. 

  173. 	      case 13: LDS(13, val); break;
    174. 

  174. 	      case 14: LDS(14, val); break;
    175. 

  175. 	      case 15: LDS(15, val); break;
    176. 

  176. 	      case 16: LDS(16, val); break;
    177. 

  177. 	      case 17: LDS(17, val); break;
    178. 

  178. 	      case 18: LDS(18, val); break;
    179. 

  179. 	      case 19: LDS(19, val); break;
    180. 

  180. 	      case 20: LDS(20, val); break;
    181. 

  181. 	      case 21: LDS(21, val); break;
    182. 

  182. 	      case 22: LDS(22, val); break;
    183. 

  183. 	      case 23: LDS(23, val); break;
    184. 

  184. 	      case 24: LDS(24, val); break;
    185. 

  185. 	      case 25: LDS(25, val); break;
    186. 

  186. 	      case 26: LDS(26, val); break;
    187. 

  187. 	      case 27: LDS(27, val); break;
    188. 

  188. 	      case 28: LDS(28, val); break;
    189. 

  189. 	      case 29: LDS(29, val); break;
    190. 

  190. 	      case 30: LDS(30, val); break;
    191. 

  191. 	      case 31: LDS(31, val); break;
    192. 

  192. 	}
    193. 

  193. }
    194. 

  194.