util/ectool/ec.c

   1 /* This file is part of the ectool project. */
   2 /* SPDX-License-Identifier: GPL-2.0-only */
   3
   4 #include <stdio.h>
   5 #include <stdint.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <unistd.h>
   9 #if !(defined __NetBSD__ || defined __OpenBSD__)
  10 #include <sys/io.h>
  11 #endif
  12 #include "ec.h"
  13
  14 static int ec_data = 0x62;
  15 static int ec_sc = 0x66;
  16
  17 #if defined __NetBSD__ || defined __OpenBSD__
  18 #include <machine/sysarch.h>
  19 static uint8_t inb(unsigned port)
  20 {
  21         uint8_t data;
  22         __asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
  23         return data;
  24 }
  25 static __inline void outb(uint8_t data, unsigned port)
  26 {
  27         __asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
  28 }
  29 #endif
  30
  31 extern int verbose;
  32
  33 #define debug(x...) if (verbose) printf(x)
  34
  35 int send_ec_command(uint8_t command)
  36 {
  37         int timeout;
  38
  39         timeout = 0x7ff;
  40         while ((inb(ec_sc) & EC_IBF) && --timeout) {
  41                 usleep(10);
  42                 if ((timeout & 0xff) == 0)
  43                         debug(".");
  44         }
  45         if (!timeout) {
  46                 debug("Timeout while sending command 0x%02x to EC!\n",
  47                        command);
  48                 // return -1;
  49         }
  50
  51         outb(command, ec_sc);
  52         return 0;
  53 }
  54
  55 int send_ec_data(uint8_t data)
  56 {
  57         int timeout;
  58
  59         timeout = 0x7ff;
  60         while ((inb(ec_sc) & EC_IBF) && --timeout) {    // wait for IBF = 0
  61                 usleep(10);
  62                 if ((timeout & 0xff) == 0)
  63                         debug(".");
  64         }
  65         if (!timeout) {
  66                 debug("Timeout while sending data 0x%02x to EC!\n", data);
  67                 // return -1;
  68         }
  69
  70         outb(data, ec_data);
  71
  72         return 0;
  73 }
  74
  75 int send_ec_data_nowait(uint8_t data)
  76 {
  77         outb(data, ec_data);
  78
  79         return 0;
  80 }
  81
  82 uint8_t recv_ec_data(void)
  83 {
  84         int timeout;
  85         uint8_t data;
  86
  87         timeout = 0x7fff;
  88         while (--timeout) {     // Wait for OBF = 1
  89                 if (inb(ec_sc) & EC_OBF)
  90                         break;
  91
  92                 usleep(10);
  93                 if ((timeout & 0xff) == 0)
  94                         debug(".");
  95         }
  96         if (!timeout) {
  97                 debug("\nTimeout while receiving data from EC!\n");
  98                 // return -1;
  99         }
 100
 101         data = inb(ec_data);
 102         debug("recv_ec_data: 0x%02x\n", data);
 103
 104         return data;
 105 }
 106
 107 uint8_t ec_read(uint8_t addr)
 108 {
 109         send_ec_command(RD_EC);
 110         send_ec_data(addr);
 111
 112         return recv_ec_data();
 113 }
 114
 115 uint8_t ec_ext_read(uint16_t addr)
 116 {
 117         send_ec_command(WR_EC);
 118         send_ec_data(0x02);
 119         send_ec_data(addr & 0xff);
 120         send_ec_command(RX_EC);
 121         send_ec_data(addr >> 8);
 122
 123         return recv_ec_data();
 124 }
 125
 126 int ec_ext_write(uint16_t addr, uint8_t data)
 127 {
 128         send_ec_command(WR_EC);
 129         send_ec_data(0x02);
 130         send_ec_data(addr & 0xff);
 131         send_ec_command(WX_EC);
 132         send_ec_data(addr >> 8);
 133
 134         return send_ec_data(data);
 135 }
 136
 137 int ec_write(uint8_t addr, uint8_t data)
 138 {
 139         send_ec_command(WR_EC);
 140         send_ec_data(addr);
 141
 142         return send_ec_data(data);
 143 }
 144
 145 uint8_t ec_idx_read(uint16_t addr)
 146 {
 147         uint16_t lpc_idx = 0x380;
 148
 149         outb(addr & 0xff, lpc_idx + 2);
 150         outb(addr >> 8, lpc_idx + 1);
 151
 152         return inb(lpc_idx + 3);
 153 }
 154
 155 uint8_t ec_query(void)
 156 {
 157         send_ec_command(QR_EC);
 158         return recv_ec_data();
 159 }
 160
 161 int get_ec_ports(void)
 162 {
 163         FILE *fp = fopen("/proc/ioports", "r");
 164         int data = 0, cmd = 0;
 165         char line[100];
 166
 167         if (fp == NULL)
 168                 return -1;
 169
 170         while (!feof(fp) && (data == 0 || cmd == 0)) {
 171                 fgets(line, sizeof(line), fp);
 172                 if (strstr(line, "EC data") != NULL)
 173                         data = strtol(line, NULL, 16);
 174
 175                 if (strstr(line, "EC cmd") != NULL)
 176                         cmd = strtol(line, NULL, 16);
 177         }
 178
 179         fclose(fp);
 180         if (data != 0 && cmd != 0) {
 181                 debug("EC data = 0x%x, EC cmd = 0x%x\n", data, cmd);
 182                 ec_data = data;
 183                 ec_sc = cmd;
 184         } else {
 185                 return -1;
 186         }
 187         return 0;
 188 }