via-rng.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  1. /*
  2. * RNG driver for VIA RNGs
  3. *
  4. * Copyright 2005 (c) MontaVista Software, Inc.
  5. *
  6. * with the majority of the code coming from:
  7. *
  8. * Hardware driver for the Intel/AMD/VIA Random Number Generators (RNG)
  9. * (c) Copyright 2003 Red Hat Inc <jgarzik@redhat.com>
  10. *
  11. * derived from
  12. *
  13. * Hardware driver for the AMD 768 Random Number Generator (RNG)
  14. * (c) Copyright 2001 Red Hat Inc <alan@redhat.com>
  15. *
  16. * derived from
  17. *
  18. * Hardware driver for Intel i810 Random Number Generator (RNG)
  19. * Copyright 2000,2001 Jeff Garzik <jgarzik@pobox.com>
  20. * Copyright 2000,2001 Philipp Rumpf <prumpf@mandrakesoft.com>
  21. *
  22. * This file is licensed under the terms of the GNU General Public
  23. * License version 2. This program is licensed "as is" without any
  24. * warranty of any kind, whether express or implied.
  25. */
  26. #include <linux/module.h>
  27. #include <linux/kernel.h>
  28. #include <linux/hw_random.h>
  29. #include <linux/delay.h>
  30. #include <asm/io.h>
  31. #include <asm/msr.h>
  32. #include <asm/cpufeature.h>
  33. #define PFX KBUILD_MODNAME ": "
  34. enum {
  35. VIA_STRFILT_CNT_SHIFT = 16,
  36. VIA_STRFILT_FAIL = (1 << 15),
  37. VIA_STRFILT_ENABLE = (1 << 14),
  38. VIA_RAWBITS_ENABLE = (1 << 13),
  39. VIA_RNG_ENABLE = (1 << 6),
  40. VIA_NOISESRC1 = (1 << 8),
  41. VIA_NOISESRC2 = (1 << 9),
  42. VIA_XSTORE_CNT_MASK = 0x0F,
  43. VIA_RNG_CHUNK_8 = 0x00, /* 64 rand bits, 64 stored bits */
  44. VIA_RNG_CHUNK_4 = 0x01, /* 32 rand bits, 32 stored bits */
  45. VIA_RNG_CHUNK_4_MASK = 0xFFFFFFFF,
  46. VIA_RNG_CHUNK_2 = 0x02, /* 16 rand bits, 32 stored bits */
  47. VIA_RNG_CHUNK_2_MASK = 0xFFFF,
  48. VIA_RNG_CHUNK_1 = 0x03, /* 8 rand bits, 32 stored bits */
  49. VIA_RNG_CHUNK_1_MASK = 0xFF,
  50. };
  51. /*
  52. * Investigate using the 'rep' prefix to obtain 32 bits of random data
  53. * in one insn. The upside is potentially better performance. The
  54. * downside is that the instruction becomes no longer atomic. Due to
  55. * this, just like familiar issues with /dev/random itself, the worst
  56. * case of a 'rep xstore' could potentially pause a cpu for an
  57. * unreasonably long time. In practice, this condition would likely
  58. * only occur when the hardware is failing. (or so we hope :))
  59. *
  60. * Another possible performance boost may come from simply buffering
  61. * until we have 4 bytes, thus returning a u32 at a time,
  62. * instead of the current u8-at-a-time.
  63. */
  64. static inline u32 xstore(u32 *addr, u32 edx_in)
  65. {
  66. u32 eax_out;
  67. asm(".byte 0x0F,0xA7,0xC0 /* xstore %%edi (addr=%0) */"
  68. :"=m"(*addr), "=a"(eax_out)
  69. :"D"(addr), "d"(edx_in));
  70. return eax_out;
  71. }
  72. static int via_rng_data_present(struct hwrng *rng, int wait)
  73. {
  74. u32 bytes_out;
  75. u32 *via_rng_datum = (u32 *)(&rng->priv);
  76. int i;
  77. /* We choose the recommended 1-byte-per-instruction RNG rate,
  78. * for greater randomness at the expense of speed. Larger
  79. * values 2, 4, or 8 bytes-per-instruction yield greater
  80. * speed at lesser randomness.
  81. *
  82. * If you change this to another VIA_CHUNK_n, you must also
  83. * change the ->n_bytes values in rng_vendor_ops[] tables.
  84. * VIA_CHUNK_8 requires further code changes.
  85. *
  86. * A copy of MSR_VIA_RNG is placed in eax_out when xstore
  87. * completes.
  88. */
  89. for (i = 0; i < 20; i++) {
  90. *via_rng_datum = 0; /* paranoia, not really necessary */
  91. bytes_out = xstore(via_rng_datum, VIA_RNG_CHUNK_1);
  92. bytes_out &= VIA_XSTORE_CNT_MASK;
  93. if (bytes_out || !wait)
  94. break;
  95. udelay(10);
  96. }
  97. return bytes_out ? 1 : 0;
  98. }
  99. static int via_rng_data_read(struct hwrng *rng, u32 *data)
  100. {
  101. u32 via_rng_datum = (u32)rng->priv;
  102. *data = via_rng_datum;
  103. return 1;
  104. }
  105. static int via_rng_init(struct hwrng *rng)
  106. {
  107. struct cpuinfo_x86 *c = &cpu_data(0);
  108. u32 lo, hi, old_lo;
  109. /* Control the RNG via MSR. Tread lightly and pay very close
  110. * close attention to values written, as the reserved fields
  111. * are documented to be "undefined and unpredictable"; but it
  112. * does not say to write them as zero, so I make a guess that
  113. * we restore the values we find in the register.
  114. */
  115. rdmsr(MSR_VIA_RNG, lo, hi);
  116. old_lo = lo;
  117. lo &= ~(0x7f << VIA_STRFILT_CNT_SHIFT);
  118. lo &= ~VIA_XSTORE_CNT_MASK;
  119. lo &= ~(VIA_STRFILT_ENABLE | VIA_STRFILT_FAIL | VIA_RAWBITS_ENABLE);
  120. lo |= VIA_RNG_ENABLE;
  121. lo |= VIA_NOISESRC1;
  122. /* Enable secondary noise source on CPUs where it is present. */
  123. /* Nehemiah stepping 8 and higher */
  124. if ((c->x86_model == 9) && (c->x86_mask > 7))
  125. lo |= VIA_NOISESRC2;
  126. /* Esther */
  127. if (c->x86_model >= 10)
  128. lo |= VIA_NOISESRC2;
  129. if (lo != old_lo)
  130. wrmsr(MSR_VIA_RNG, lo, hi);
  131. /* perhaps-unnecessary sanity check; remove after testing if
  132. unneeded */
  133. rdmsr(MSR_VIA_RNG, lo, hi);
  134. if ((lo & VIA_RNG_ENABLE) == 0) {
  135. printk(KERN_ERR PFX "cannot enable VIA C3 RNG, aborting\n");
  136. return -ENODEV;
  137. }
  138. return 0;
  139. }
  140. static struct hwrng via_rng = {
  141. .name = "via",
  142. .init = via_rng_init,
  143. .data_present = via_rng_data_present,
  144. .data_read = via_rng_data_read,
  145. };
  146. static int __init mod_init(void)
  147. {
  148. int err;
  149. if (!cpu_has_xstore)
  150. return -ENODEV;
  151. printk(KERN_INFO "VIA RNG detected\n");
  152. err = hwrng_register(&via_rng);
  153. if (err) {
  154. printk(KERN_ERR PFX "RNG registering failed (%d)\n",
  155. err);
  156. goto out;
  157. }
  158. out:
  159. return err;
  160. }
  161. static void __exit mod_exit(void)
  162. {
  163. hwrng_unregister(&via_rng);
  164. }
  165. module_init(mod_init);
  166. module_exit(mod_exit);
  167. MODULE_DESCRIPTION("H/W RNG driver for VIA chipsets");
  168. MODULE_LICENSE("GPL");