1 /*- 2 * Copyright (c) 2016 Netflix, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 #include <sys/cdefs.h> 27 __FBSDID("$FreeBSD$"); 28 29 #include <sys/param.h> 30 #include <sys/ioccom.h> 31 32 #include <ctype.h> 33 #include <err.h> 34 #include <fcntl.h> 35 #include <stdbool.h> 36 #include <stddef.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <string.h> 40 #include <unistd.h> 41 42 #include "nvmecontrol.h" 43 44 _Static_assert(sizeof(struct nvme_power_state) == 256 / NBBY, 45 "nvme_power_state size wrong"); 46 47 #define POWER_NONE 0xffffffffu 48 49 static struct options { 50 bool list; 51 uint32_t power; 52 uint32_t workload; 53 const char *dev; 54 } opt = { 55 .list = false, 56 .power = POWER_NONE, 57 .workload = 0, 58 .dev = NULL, 59 }; 60 61 static void 62 power_list_one(int i, struct nvme_power_state *nps) 63 { 64 int mpower, apower, ipower; 65 uint8_t mps, nops, aps, apw; 66 67 mps = (nps->mps_nops >> NVME_PWR_ST_MPS_SHIFT) & 68 NVME_PWR_ST_MPS_MASK; 69 nops = (nps->mps_nops >> NVME_PWR_ST_NOPS_SHIFT) & 70 NVME_PWR_ST_NOPS_MASK; 71 apw = (nps->apw_aps >> NVME_PWR_ST_APW_SHIFT) & 72 NVME_PWR_ST_APW_MASK; 73 aps = (nps->apw_aps >> NVME_PWR_ST_APS_SHIFT) & 74 NVME_PWR_ST_APS_MASK; 75 76 mpower = nps->mp; 77 if (mps == 0) 78 mpower *= 100; 79 ipower = nps->idlp; 80 if (nps->ips == 1) 81 ipower *= 100; 82 apower = nps->actp; 83 if (aps == 1) 84 apower *= 100; 85 printf("%2d: %2d.%04dW%c %3d.%03dms %3d.%03dms %2d %2d %2d %2d %2d.%04dW %2d.%04dW %d\n", 86 i, mpower / 10000, mpower % 10000, 87 nops ? '*' : ' ', nps->enlat / 1000, nps->enlat % 1000, 88 nps->exlat / 1000, nps->exlat % 1000, nps->rrt, nps->rrl, 89 nps->rwt, nps->rwl, ipower / 10000, ipower % 10000, 90 apower / 10000, apower % 10000, apw); 91 } 92 93 static void 94 power_list(struct nvme_controller_data *cdata) 95 { 96 int i; 97 98 printf("\nPower States Supported: %d\n\n", cdata->npss + 1); 99 printf(" # Max pwr Enter Lat Exit Lat RT RL WT WL Idle Pwr Act Pwr Workloadd\n"); 100 printf("-- -------- --------- --------- -- -- -- -- -------- -------- --\n"); 101 for (i = 0; i <= cdata->npss; i++) 102 power_list_one(i, &cdata->power_state[i]); 103 } 104 105 static void 106 power_set(int fd, int power_val, int workload, int perm) 107 { 108 struct nvme_pt_command pt; 109 uint32_t p; 110 111 p = perm ? (1u << 31) : 0; 112 memset(&pt, 0, sizeof(pt)); 113 pt.cmd.opc = NVME_OPC_SET_FEATURES; 114 pt.cmd.cdw10 = htole32(NVME_FEAT_POWER_MANAGEMENT | p); 115 pt.cmd.cdw11 = htole32(power_val | (workload << 5)); 116 117 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 118 err(1, "set feature power mgmt request failed"); 119 120 if (nvme_completion_is_error(&pt.cpl)) 121 errx(1, "set feature power mgmt request returned error"); 122 } 123 124 static void 125 power_show(int fd) 126 { 127 struct nvme_pt_command pt; 128 129 memset(&pt, 0, sizeof(pt)); 130 pt.cmd.opc = NVME_OPC_GET_FEATURES; 131 pt.cmd.cdw10 = htole32(NVME_FEAT_POWER_MANAGEMENT); 132 133 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 134 err(1, "set feature power mgmt request failed"); 135 136 if (nvme_completion_is_error(&pt.cpl)) 137 errx(1, "set feature power mgmt request returned error"); 138 139 printf("Current Power Mode is %d\n", pt.cpl.cdw0); 140 } 141 142 static void 143 power(const struct cmd *f, int argc, char *argv[]) 144 { 145 struct nvme_controller_data cdata; 146 int fd; 147 char *path; 148 uint32_t nsid; 149 150 if (arg_parse(argc, argv, f)) 151 return; 152 153 if (opt.list && opt.power != POWER_NONE) { 154 fprintf(stderr, "Can't set power and list power states\n"); 155 arg_help(argc, argv, f); 156 } 157 158 open_dev(opt.dev, &fd, 1, 1); 159 get_nsid(fd, &path, &nsid); 160 if (nsid != 0) { 161 close(fd); 162 open_dev(path, &fd, 1, 1); 163 } 164 free(path); 165 166 if (opt.list) { 167 read_controller_data(fd, &cdata); 168 power_list(&cdata); 169 goto out; 170 } 171 172 if (opt.power != POWER_NONE) { 173 power_set(fd, opt.power, opt.workload, 0); 174 goto out; 175 } 176 power_show(fd); 177 178 out: 179 close(fd); 180 exit(0); 181 } 182 183 static const struct opts power_opts[] = { 184 #define OPT(l, s, t, opt, addr, desc) { l, s, t, &opt.addr, desc } 185 OPT("list", 'l', arg_none, opt, list, 186 "List the valid power states"), 187 OPT("power", 'p', arg_uint32, opt, power, 188 "Set the power state"), 189 OPT("workload", 'w', arg_uint32, opt, workload, 190 "Set the workload"), 191 { NULL, 0, arg_none, NULL, NULL } 192 }; 193 #undef OPT 194 195 static const struct args power_args[] = { 196 { arg_string, &opt.dev, "controller-id|namespace-id" }, 197 { arg_none, NULL, NULL }, 198 }; 199 200 static struct cmd power_cmd = { 201 .name = "power", 202 .fn = power, 203 .descr = "Manage power states for the drive", 204 .ctx_size = sizeof(opt), 205 .opts = power_opts, 206 .args = power_args, 207 }; 208 209 CMD_COMMAND(power_cmd); 210