cpcmd.c 2.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
  1. /*
  2. * arch/s390/kernel/cpcmd.c
  3. *
  4. * S390 version
  5. * Copyright (C) 1999,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6. * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  7. * Christian Borntraeger (cborntra@de.ibm.com),
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/slab.h>
  12. #include <linux/spinlock.h>
  13. #include <linux/stddef.h>
  14. #include <linux/string.h>
  15. #include <asm/ebcdic.h>
  16. #include <asm/cpcmd.h>
  17. #include <asm/system.h>
  18. #include <asm/io.h>
  19. static DEFINE_SPINLOCK(cpcmd_lock);
  20. static char cpcmd_buf[241];
  21. /*
  22. * __cpcmd has some restrictions over cpcmd
  23. * - the response buffer must reside below 2GB (if any)
  24. * - __cpcmd is unlocked and therefore not SMP-safe
  25. */
  26. int __cpcmd(const char *cmd, char *response, int rlen, int *response_code)
  27. {
  28. unsigned cmdlen;
  29. int return_code, return_len;
  30. cmdlen = strlen(cmd);
  31. BUG_ON(cmdlen > 240);
  32. memcpy(cpcmd_buf, cmd, cmdlen);
  33. ASCEBC(cpcmd_buf, cmdlen);
  34. if (response != NULL && rlen > 0) {
  35. register unsigned long reg2 asm ("2") = (addr_t) cpcmd_buf;
  36. register unsigned long reg3 asm ("3") = (addr_t) response;
  37. register unsigned long reg4 asm ("4") = cmdlen | 0x40000000L;
  38. register unsigned long reg5 asm ("5") = rlen;
  39. memset(response, 0, rlen);
  40. asm volatile(
  41. #ifndef CONFIG_64BIT
  42. " diag %2,%0,0x8\n"
  43. " brc 8,1f\n"
  44. " ar %1,%4\n"
  45. #else /* CONFIG_64BIT */
  46. " sam31\n"
  47. " diag %2,%0,0x8\n"
  48. " sam64\n"
  49. " brc 8,1f\n"
  50. " agr %1,%4\n"
  51. #endif /* CONFIG_64BIT */
  52. "1:\n"
  53. : "+d" (reg4), "+d" (reg5)
  54. : "d" (reg2), "d" (reg3), "d" (rlen) : "cc");
  55. return_code = (int) reg4;
  56. return_len = (int) reg5;
  57. EBCASC(response, rlen);
  58. } else {
  59. register unsigned long reg2 asm ("2") = (addr_t) cpcmd_buf;
  60. register unsigned long reg3 asm ("3") = cmdlen;
  61. return_len = 0;
  62. asm volatile(
  63. #ifndef CONFIG_64BIT
  64. " diag %1,%0,0x8\n"
  65. #else /* CONFIG_64BIT */
  66. " sam31\n"
  67. " diag %1,%0,0x8\n"
  68. " sam64\n"
  69. #endif /* CONFIG_64BIT */
  70. : "+d" (reg3) : "d" (reg2) : "cc");
  71. return_code = (int) reg3;
  72. }
  73. if (response_code != NULL)
  74. *response_code = return_code;
  75. return return_len;
  76. }
  77. EXPORT_SYMBOL(__cpcmd);
  78. int cpcmd(const char *cmd, char *response, int rlen, int *response_code)
  79. {
  80. char *lowbuf;
  81. int len;
  82. unsigned long flags;
  83. if ((virt_to_phys(response) != (unsigned long) response) ||
  84. (((unsigned long)response + rlen) >> 31)) {
  85. lowbuf = kmalloc(rlen, GFP_KERNEL | GFP_DMA);
  86. if (!lowbuf) {
  87. printk(KERN_WARNING
  88. "cpcmd: could not allocate response buffer\n");
  89. return -ENOMEM;
  90. }
  91. spin_lock_irqsave(&cpcmd_lock, flags);
  92. len = __cpcmd(cmd, lowbuf, rlen, response_code);
  93. spin_unlock_irqrestore(&cpcmd_lock, flags);
  94. memcpy(response, lowbuf, rlen);
  95. kfree(lowbuf);
  96. } else {
  97. spin_lock_irqsave(&cpcmd_lock, flags);
  98. len = __cpcmd(cmd, response, rlen, response_code);
  99. spin_unlock_irqrestore(&cpcmd_lock, flags);
  100. }
  101. return len;
  102. }
  103. EXPORT_SYMBOL(cpcmd);