/** * dpbp_open() - Open a control session for the specified object. * @mc_io: Pointer to MC portal's I/O object * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @dpbp_id: DPBP unique ID * @token: Returned token; use in subsequent API calls * * This function can be used to open a control session for an * already created object; an object may have been declared in * the DPL or by calling the dpbp_create function. * This function returns a unique authentication token, * associated with the specific object ID and the specific MC * portal; this token must be used in all subsequent commands for * this specific object * * Return: '0' on Success; Error code otherwise. */ int dpbp_open(struct fsl_mc_io *mc_io, u32 cmd_flags, int dpbp_id, u16 *token) { struct mc_command cmd = { 0 }; struct dpbp_cmd_open *cmd_params; int err; /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN, cmd_flags, 0); cmd_params = (struct dpbp_cmd_open *)cmd.params; cmd_params->dpbp_id = cpu_to_le32(dpbp_id); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); if (err) return err; /* retrieve response parameters */ *token = mc_cmd_hdr_read_token(&cmd); return err; }
/** * Waits for the completion of an MC command doing atomic polling. * udelay() is called between polling iterations. * * @mc_io: MC I/O object to be used * @cmd: command buffer to receive MC response * @mc_status: MC command completion status */ static int mc_polling_wait_atomic(struct fsl_mc_io *mc_io, struct mc_command *cmd, enum mc_cmd_status *mc_status) { enum mc_cmd_status status; unsigned long timeout_usecs = MC_CMD_COMPLETION_TIMEOUT_MS * 1000; BUILD_BUG_ON((MC_CMD_COMPLETION_TIMEOUT_MS * 1000) % MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS != 0); for (;;) { status = mc_read_response(mc_io->portal_virt_addr, cmd); if (status != MC_CMD_STATUS_READY) break; udelay(MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS); timeout_usecs -= MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS; if (timeout_usecs == 0) { dev_dbg(mc_io->dev, "MC command timed out (portal: %#llx, obj handle: %#x, command: %#x)\n", mc_io->portal_phys_addr, (unsigned int)mc_cmd_hdr_read_token(cmd), (unsigned int)mc_cmd_hdr_read_cmdid(cmd)); return -ETIMEDOUT; } } *mc_status = status; return 0; }
/** * Sends a command to the MC device using the given MC I/O object * * @mc_io: MC I/O object to be used * @cmd: command to be sent * * Returns '0' on Success; Error code otherwise. */ int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd) { int error; enum mc_cmd_status status; unsigned long irq_flags = 0; if (WARN_ON(in_irq() && !(mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL))) return -EINVAL; if (mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL) spin_lock_irqsave(&mc_io->spinlock, irq_flags); else mutex_lock(&mc_io->mutex); /* * Send command to the MC hardware: */ mc_write_command(mc_io->portal_virt_addr, cmd); /* * Wait for response from the MC hardware: */ if (!(mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL)) error = mc_polling_wait_preemptible(mc_io, cmd, &status); else error = mc_polling_wait_atomic(mc_io, cmd, &status); if (error < 0) goto common_exit; if (status != MC_CMD_STATUS_OK) { dev_dbg(mc_io->dev, "MC command failed: portal: %#llx, obj handle: %#x, command: %#x, status: %s (%#x)\n", mc_io->portal_phys_addr, (unsigned int)mc_cmd_hdr_read_token(cmd), (unsigned int)mc_cmd_hdr_read_cmdid(cmd), mc_status_to_string(status), (unsigned int)status); error = mc_status_to_error(status); goto common_exit; } error = 0; common_exit: if (mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL) spin_unlock_irqrestore(&mc_io->spinlock, irq_flags); else mutex_unlock(&mc_io->mutex); return error; }
/** * Waits for the completion of an MC command doing preemptible polling. * uslepp_range() is called between polling iterations. * * @mc_io: MC I/O object to be used * @cmd: command buffer to receive MC response * @mc_status: MC command completion status */ static int mc_polling_wait_preemptible(struct fsl_mc_io *mc_io, struct mc_command *cmd, enum mc_cmd_status *mc_status) { enum mc_cmd_status status; unsigned long jiffies_until_timeout = jiffies + msecs_to_jiffies(MC_CMD_COMPLETION_TIMEOUT_MS); /* * Wait for response from the MC hardware: */ for (;;) { status = mc_read_response(mc_io->portal_virt_addr, cmd); if (status != MC_CMD_STATUS_READY) break; /* * TODO: When MC command completion interrupts are supported * call wait function here instead of usleep_range() */ usleep_range(MC_CMD_COMPLETION_POLLING_MIN_SLEEP_USECS, MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS); if (time_after_eq(jiffies, jiffies_until_timeout)) { dev_dbg(mc_io->dev, "MC command timed out (portal: %#llx, obj handle: %#x, command: %#x)\n", mc_io->portal_phys_addr, (unsigned int)mc_cmd_hdr_read_token(cmd), (unsigned int)mc_cmd_hdr_read_cmdid(cmd)); return -ETIMEDOUT; } } *mc_status = status; return 0; }
/** * dpbp_create() - Create the DPBP object. * @mc_io: Pointer to MC portal's I/O object * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @cfg: Configuration structure * @token: Returned token; use in subsequent API calls * * Create the DPBP object, allocate required resources and * perform required initialization. * * The object can be created either by declaring it in the * DPL file, or by calling this function. * This function returns a unique authentication token, * associated with the specific object ID and the specific MC * portal; this token must be used in all subsequent calls to * this specific object. For objects that are created using the * DPL file, call dpbp_open function to get an authentication * token first. * * Return: '0' on Success; Error code otherwise. */ int dpbp_create(struct fsl_mc_io *mc_io, u32 cmd_flags, const struct dpbp_cfg *cfg, u16 *token) { struct mc_command cmd = { 0 }; int err; (void)(cfg); /* unused */ /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE, cmd_flags, 0); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); if (err) return err; /* retrieve response parameters */ *token = mc_cmd_hdr_read_token(&cmd); return 0; }