arch/s390/kernel/cpcmd.c

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