1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2023 Advanced Micro Devices, Inc */
4 #include <linux/errno.h>
6 #include <linux/utsname.h>
10 int pdsc_err_to_errno(enum pds_core_status_code code)
58 bool pdsc_is_fw_running(struct pdsc *pdsc)
60 pdsc->fw_status = ioread8(&pdsc->info_regs->fw_status);
61 pdsc->last_fw_time = jiffies;
62 pdsc->last_hb = ioread32(&pdsc->info_regs->fw_heartbeat);
64 /* Firmware is useful only if the running bit is set and
65 * fw_status != 0xff (bad PCI read)
67 return (pdsc->fw_status != PDS_RC_BAD_PCI) &&
68 (pdsc->fw_status & PDS_CORE_FW_STS_F_RUNNING);
71 bool pdsc_is_fw_good(struct pdsc *pdsc)
73 bool fw_running = pdsc_is_fw_running(pdsc);
76 /* Make sure to update the cached fw_status by calling
77 * pdsc_is_fw_running() before getting the generation
79 gen = pdsc->fw_status & PDS_CORE_FW_STS_F_GENERATION;
81 return fw_running && gen == pdsc->fw_generation;
84 static u8 pdsc_devcmd_status(struct pdsc *pdsc)
86 return ioread8(&pdsc->cmd_regs->comp.status);
89 static bool pdsc_devcmd_done(struct pdsc *pdsc)
91 return ioread32(&pdsc->cmd_regs->done) & PDS_CORE_DEV_CMD_DONE;
94 static void pdsc_devcmd_dbell(struct pdsc *pdsc)
96 iowrite32(0, &pdsc->cmd_regs->done);
97 iowrite32(1, &pdsc->cmd_regs->doorbell);
100 static void pdsc_devcmd_clean(struct pdsc *pdsc)
102 iowrite32(0, &pdsc->cmd_regs->doorbell);
103 memset_io(&pdsc->cmd_regs->cmd, 0, sizeof(pdsc->cmd_regs->cmd));
106 static const char *pdsc_devcmd_str(int opcode)
109 case PDS_CORE_CMD_NOP:
110 return "PDS_CORE_CMD_NOP";
111 case PDS_CORE_CMD_IDENTIFY:
112 return "PDS_CORE_CMD_IDENTIFY";
113 case PDS_CORE_CMD_RESET:
114 return "PDS_CORE_CMD_RESET";
115 case PDS_CORE_CMD_INIT:
116 return "PDS_CORE_CMD_INIT";
117 case PDS_CORE_CMD_FW_DOWNLOAD:
118 return "PDS_CORE_CMD_FW_DOWNLOAD";
119 case PDS_CORE_CMD_FW_CONTROL:
120 return "PDS_CORE_CMD_FW_CONTROL";
122 return "PDS_CORE_CMD_UNKNOWN";
126 static int pdsc_devcmd_wait(struct pdsc *pdsc, u8 opcode, int max_seconds)
128 struct device *dev = pdsc->dev;
129 unsigned long start_time;
130 unsigned long max_wait;
131 unsigned long duration;
138 start_time = jiffies;
139 max_wait = start_time + (max_seconds * HZ);
141 while (!done && !timeout) {
142 running = pdsc_is_fw_running(pdsc);
146 done = pdsc_devcmd_done(pdsc);
150 timeout = time_after(jiffies, max_wait);
154 usleep_range(100, 200);
156 duration = jiffies - start_time;
158 if (done && duration > HZ)
159 dev_dbg(dev, "DEVCMD %d %s after %ld secs\n",
160 opcode, pdsc_devcmd_str(opcode), duration / HZ);
162 if ((!done || timeout) && running) {
163 dev_err(dev, "DEVCMD %d %s timeout, done %d timeout %d max_seconds=%d\n",
164 opcode, pdsc_devcmd_str(opcode), done, timeout,
167 pdsc_devcmd_clean(pdsc);
170 status = pdsc_devcmd_status(pdsc);
171 err = pdsc_err_to_errno(status);
172 if (err && err != -EAGAIN)
173 dev_err(dev, "DEVCMD %d %s failed, status=%d err %d %pe\n",
174 opcode, pdsc_devcmd_str(opcode), status, err,
180 int pdsc_devcmd_locked(struct pdsc *pdsc, union pds_core_dev_cmd *cmd,
181 union pds_core_dev_comp *comp, int max_seconds)
185 memcpy_toio(&pdsc->cmd_regs->cmd, cmd, sizeof(*cmd));
186 pdsc_devcmd_dbell(pdsc);
187 err = pdsc_devcmd_wait(pdsc, cmd->opcode, max_seconds);
188 memcpy_fromio(comp, &pdsc->cmd_regs->comp, sizeof(*comp));
190 if ((err == -ENXIO || err == -ETIMEDOUT) && pdsc->wq)
191 queue_work(pdsc->wq, &pdsc->health_work);
196 int pdsc_devcmd(struct pdsc *pdsc, union pds_core_dev_cmd *cmd,
197 union pds_core_dev_comp *comp, int max_seconds)
201 mutex_lock(&pdsc->devcmd_lock);
202 err = pdsc_devcmd_locked(pdsc, cmd, comp, max_seconds);
203 mutex_unlock(&pdsc->devcmd_lock);
208 int pdsc_devcmd_init(struct pdsc *pdsc)
210 union pds_core_dev_comp comp = {};
211 union pds_core_dev_cmd cmd = {
212 .opcode = PDS_CORE_CMD_INIT,
215 return pdsc_devcmd(pdsc, &cmd, &comp, pdsc->devcmd_timeout);
218 int pdsc_devcmd_reset(struct pdsc *pdsc)
220 union pds_core_dev_comp comp = {};
221 union pds_core_dev_cmd cmd = {
222 .reset.opcode = PDS_CORE_CMD_RESET,
225 return pdsc_devcmd(pdsc, &cmd, &comp, pdsc->devcmd_timeout);
228 static int pdsc_devcmd_identify_locked(struct pdsc *pdsc)
230 union pds_core_dev_comp comp = {};
231 union pds_core_dev_cmd cmd = {
232 .identify.opcode = PDS_CORE_CMD_IDENTIFY,
233 .identify.ver = PDS_CORE_IDENTITY_VERSION_1,
236 return pdsc_devcmd_locked(pdsc, &cmd, &comp, pdsc->devcmd_timeout);
239 static void pdsc_init_devinfo(struct pdsc *pdsc)
241 pdsc->dev_info.asic_type = ioread8(&pdsc->info_regs->asic_type);
242 pdsc->dev_info.asic_rev = ioread8(&pdsc->info_regs->asic_rev);
243 pdsc->fw_generation = PDS_CORE_FW_STS_F_GENERATION &
244 ioread8(&pdsc->info_regs->fw_status);
246 memcpy_fromio(pdsc->dev_info.fw_version,
247 pdsc->info_regs->fw_version,
248 PDS_CORE_DEVINFO_FWVERS_BUFLEN);
249 pdsc->dev_info.fw_version[PDS_CORE_DEVINFO_FWVERS_BUFLEN] = 0;
251 memcpy_fromio(pdsc->dev_info.serial_num,
252 pdsc->info_regs->serial_num,
253 PDS_CORE_DEVINFO_SERIAL_BUFLEN);
254 pdsc->dev_info.serial_num[PDS_CORE_DEVINFO_SERIAL_BUFLEN] = 0;
256 dev_dbg(pdsc->dev, "fw_version %s\n", pdsc->dev_info.fw_version);
259 static int pdsc_identify(struct pdsc *pdsc)
261 struct pds_core_drv_identity drv = {};
266 drv.drv_type = cpu_to_le32(PDS_DRIVER_LINUX);
267 /* Catching the return quiets a Wformat-truncation complaint */
268 n = snprintf(drv.driver_ver_str, sizeof(drv.driver_ver_str),
269 "%s %s", PDS_CORE_DRV_NAME, utsname()->release);
270 if (n > sizeof(drv.driver_ver_str))
271 dev_dbg(pdsc->dev, "release name truncated, don't care\n");
273 /* Next let's get some info about the device
274 * We use the devcmd_lock at this level in order to
275 * get safe access to the cmd_regs->data before anyone
276 * else can mess it up
278 mutex_lock(&pdsc->devcmd_lock);
280 sz = min_t(size_t, sizeof(drv), sizeof(pdsc->cmd_regs->data));
281 memcpy_toio(&pdsc->cmd_regs->data, &drv, sz);
283 err = pdsc_devcmd_identify_locked(pdsc);
285 sz = min_t(size_t, sizeof(pdsc->dev_ident),
286 sizeof(pdsc->cmd_regs->data));
287 memcpy_fromio(&pdsc->dev_ident, &pdsc->cmd_regs->data, sz);
289 mutex_unlock(&pdsc->devcmd_lock);
292 dev_err(pdsc->dev, "Cannot identify device: %pe\n",
297 if (isprint(pdsc->dev_info.fw_version[0]) &&
298 isascii(pdsc->dev_info.fw_version[0]))
299 dev_info(pdsc->dev, "FW: %.*s\n",
300 (int)(sizeof(pdsc->dev_info.fw_version) - 1),
301 pdsc->dev_info.fw_version);
303 dev_info(pdsc->dev, "FW: (invalid string) 0x%02x 0x%02x 0x%02x 0x%02x ...\n",
304 (u8)pdsc->dev_info.fw_version[0],
305 (u8)pdsc->dev_info.fw_version[1],
306 (u8)pdsc->dev_info.fw_version[2],
307 (u8)pdsc->dev_info.fw_version[3]);
312 int pdsc_dev_reinit(struct pdsc *pdsc)
314 pdsc_init_devinfo(pdsc);
316 return pdsc_identify(pdsc);
319 int pdsc_dev_init(struct pdsc *pdsc)
324 /* Initial init and reset of device */
325 pdsc_init_devinfo(pdsc);
326 pdsc->devcmd_timeout = PDS_CORE_DEVCMD_TIMEOUT;
328 err = pdsc_devcmd_reset(pdsc);
332 err = pdsc_identify(pdsc);
336 pdsc_debugfs_add_ident(pdsc);
338 /* Now we can reserve interrupts */
339 nintrs = le32_to_cpu(pdsc->dev_ident.nintrs);
340 nintrs = min_t(unsigned int, num_online_cpus(), nintrs);
342 /* Get intr_info struct array for tracking */
343 pdsc->intr_info = kcalloc(nintrs, sizeof(*pdsc->intr_info), GFP_KERNEL);
344 if (!pdsc->intr_info) {
349 err = pci_alloc_irq_vectors(pdsc->pdev, nintrs, nintrs, PCI_IRQ_MSIX);
351 dev_err(pdsc->dev, "Can't get %d intrs from OS: %pe\n",
352 nintrs, ERR_PTR(err));
356 pdsc->nintrs = nintrs;
361 kfree(pdsc->intr_info);
362 pdsc->intr_info = NULL;