History

bus: mhi: core: Add support for downloading firmware over BHIe

MHI supports downloading the device firmware over BHI/BHIe (Boot Host Interface) protocol. Hence, this commit adds necessary helpers, which will be called during device power up stage. This is based on the patch submitted by Sujeev Dias: https://lkml.org/lkml/2018/7/9/989

Manivannan Sadhasivam committed 6 years ago

Commit cd457af1 parent 3000f853 files · +270 −0Browse files

Unified · Split

3 files
  1. drivers/bus/mhi/core/boot.c +268 −0
  2. drivers/bus/mhi/core/init.c +1 −0
  3. drivers/bus/mhi/core/internal.h +1 −0
drivers/bus/mhi/core/boot.c+268−0
@@ -18,6 +18,120 @@ · 17 unmodified lines
18#include <linux/wait.h>18#include <linux/wait.h>
19#include "internal.h"19#include "internal.h"
20 20
21static int mhi_fw_load_amss(struct mhi_controller *mhi_cntrl,
22 const struct mhi_buf *mhi_buf)
23{
24 void __iomem *base = mhi_cntrl->bhie;
25 rwlock_t *pm_lock = &mhi_cntrl->pm_lock;
26 u32 tx_status, sequence_id;
27
28 read_lock_bh(pm_lock);
29 if (!MHI_REG_ACCESS_VALID(mhi_cntrl->pm_state)) {
30 read_unlock_bh(pm_lock);
31 return -EIO;
32 }
33
34 mhi_write_reg(mhi_cntrl, base, BHIE_TXVECADDR_HIGH_OFFS,
35 upper_32_bits(mhi_buf->dma_addr));
36
37 mhi_write_reg(mhi_cntrl, base, BHIE_TXVECADDR_LOW_OFFS,
38 lower_32_bits(mhi_buf->dma_addr));
39
40 mhi_write_reg(mhi_cntrl, base, BHIE_TXVECSIZE_OFFS, mhi_buf->len);
41
42 sequence_id = prandom_u32() & BHIE_TXVECSTATUS_SEQNUM_BMSK;
43 mhi_write_reg_field(mhi_cntrl, base, BHIE_TXVECDB_OFFS,
44 BHIE_TXVECDB_SEQNUM_BMSK, BHIE_TXVECDB_SEQNUM_SHFT,
45 sequence_id);
46 read_unlock_bh(pm_lock);
47
48 /* Wait for the image download to complete */
49 wait_event_timeout(mhi_cntrl->state_event,
50 MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state) ||
51 mhi_read_reg_field(mhi_cntrl, base,
52 BHIE_TXVECSTATUS_OFFS,
53 BHIE_TXVECSTATUS_STATUS_BMSK,
54 BHIE_TXVECSTATUS_STATUS_SHFT,
55 &tx_status) || tx_status,
56 msecs_to_jiffies(mhi_cntrl->timeout_ms));
57
58 if (MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state))
59 return -EIO;
60
61 return (tx_status == BHIE_TXVECSTATUS_STATUS_XFER_COMPL) ? 0 : -EIO;
62}
63
64static int mhi_fw_load_sbl(struct mhi_controller *mhi_cntrl,
65 dma_addr_t dma_addr,
66 size_t size)
67{
68 u32 tx_status, val, session_id;
69 int i, ret;
70 void __iomem *base = mhi_cntrl->bhi;
71 rwlock_t *pm_lock = &mhi_cntrl->pm_lock;
72 struct device *dev = &mhi_cntrl->mhi_dev->dev;
73 struct {
74 char *name;
75 u32 offset;
76 } error_reg[] = {
77 { "ERROR_CODE", BHI_ERRCODE },
78 { "ERROR_DBG1", BHI_ERRDBG1 },
79 { "ERROR_DBG2", BHI_ERRDBG2 },
80 { "ERROR_DBG3", BHI_ERRDBG3 },
81 { NULL },
82 };
83
84 read_lock_bh(pm_lock);
85 if (!MHI_REG_ACCESS_VALID(mhi_cntrl->pm_state)) {
86 read_unlock_bh(pm_lock);
87 goto invalid_pm_state;
88 }
89
90 dev_dbg(dev, "Starting SBL download via BHI\n");
91 mhi_write_reg(mhi_cntrl, base, BHI_STATUS, 0);
92 mhi_write_reg(mhi_cntrl, base, BHI_IMGADDR_HIGH,
93 upper_32_bits(dma_addr));
94 mhi_write_reg(mhi_cntrl, base, BHI_IMGADDR_LOW,
95 lower_32_bits(dma_addr));
96 mhi_write_reg(mhi_cntrl, base, BHI_IMGSIZE, size);
97 session_id = prandom_u32() & BHI_TXDB_SEQNUM_BMSK;
98 mhi_write_reg(mhi_cntrl, base, BHI_IMGTXDB, session_id);
99 read_unlock_bh(pm_lock);
100
101 /* Wait for the image download to complete */
102 ret = wait_event_timeout(mhi_cntrl->state_event,
103 MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state) ||
104 mhi_read_reg_field(mhi_cntrl, base, BHI_STATUS,
105 BHI_STATUS_MASK, BHI_STATUS_SHIFT,
106 &tx_status) || tx_status,
107 msecs_to_jiffies(mhi_cntrl->timeout_ms));
108 if (MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state))
109 goto invalid_pm_state;
110
111 if (tx_status == BHI_STATUS_ERROR) {
112 dev_err(dev, "Image transfer failed\n");
113 read_lock_bh(pm_lock);
114 if (MHI_REG_ACCESS_VALID(mhi_cntrl->pm_state)) {
115 for (i = 0; error_reg[i].name; i++) {
116 ret = mhi_read_reg(mhi_cntrl, base,
117 error_reg[i].offset, &val);
118 if (ret)
119 break;
120 dev_err(dev, "Reg: %s value: 0x%x\n",
121 error_reg[i].name, val);
122 }
123 }
124 read_unlock_bh(pm_lock);
125 goto invalid_pm_state;
126 }
127
128 return (!ret) ? -ETIMEDOUT : 0;
129
130invalid_pm_state:
131
132 return -EIO;
133}
134
21void mhi_free_bhie_table(struct mhi_controller *mhi_cntrl,135void mhi_free_bhie_table(struct mhi_controller *mhi_cntrl,
22 struct image_info *image_info)136 struct image_info *image_info)
23{137{
@@ -85,3 +199,157 @@ error_alloc_mhi_buf: · 61 unmodified lines
85 199
86 return -ENOMEM;200 return -ENOMEM;
87}201}
202
203static void mhi_firmware_copy(struct mhi_controller *mhi_cntrl,
204 const struct firmware *firmware,
205 struct image_info *img_info)
206{
207 size_t remainder = firmware->size;
208 size_t to_cpy;
209 const u8 *buf = firmware->data;
210 int i = 0;
211 struct mhi_buf *mhi_buf = img_info->mhi_buf;
212 struct bhi_vec_entry *bhi_vec = img_info->bhi_vec;
213
214 while (remainder) {
215 to_cpy = min(remainder, mhi_buf->len);
216 memcpy(mhi_buf->buf, buf, to_cpy);
217 bhi_vec->dma_addr = mhi_buf->dma_addr;
218 bhi_vec->size = to_cpy;
219
220 buf += to_cpy;
221 remainder -= to_cpy;
222 i++;
223 bhi_vec++;
224 mhi_buf++;
225 }
226}
227
228void mhi_fw_load_worker(struct work_struct *work)
229{
230 struct mhi_controller *mhi_cntrl;
231 const struct firmware *firmware = NULL;
232 struct image_info *image_info;
233 struct device *dev;
234 const char *fw_name;
235 void *buf;
236 dma_addr_t dma_addr;
237 size_t size;
238 int ret;
239
240 mhi_cntrl = container_of(work, struct mhi_controller, fw_worker);
241 dev = &mhi_cntrl->mhi_dev->dev;
242
243 dev_dbg(dev, "Waiting for device to enter PBL from: %s\n",
244 TO_MHI_EXEC_STR(mhi_cntrl->ee));
245
246 ret = wait_event_timeout(mhi_cntrl->state_event,
247 MHI_IN_PBL(mhi_cntrl->ee) ||
248 MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state),
249 msecs_to_jiffies(mhi_cntrl->timeout_ms));
250
251 if (!ret || MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state)) {
252 dev_err(dev, "Device MHI is not in valid state\n");
253 return;
254 }
255
256 /* If device is in pass through, do reset to ready state transition */
257 if (mhi_cntrl->ee == MHI_EE_PTHRU)
258 goto fw_load_ee_pthru;
259
260 fw_name = (mhi_cntrl->ee == MHI_EE_EDL) ?
261 mhi_cntrl->edl_image : mhi_cntrl->fw_image;
262
263 if (!fw_name || (mhi_cntrl->fbc_download && (!mhi_cntrl->sbl_size ||
264 !mhi_cntrl->seg_len))) {
265 dev_err(dev,
266 "No firmware image defined or !sbl_size || !seg_len\n");
267 return;
268 }
269
270 ret = request_firmware(&firmware, fw_name, dev);
271 if (ret) {
272 dev_err(dev, "Error loading firmware: %d\n", ret);
273 return;
274 }
275
276 size = (mhi_cntrl->fbc_download) ? mhi_cntrl->sbl_size : firmware->size;
277
278 /* SBL size provided is maximum size, not necessarily the image size */
279 if (size > firmware->size)
280 size = firmware->size;
281
282 buf = mhi_alloc_coherent(mhi_cntrl, size, &dma_addr, GFP_KERNEL);
283 if (!buf) {
284 release_firmware(firmware);
285 return;
286 }
287
288 /* Download SBL image */
289 memcpy(buf, firmware->data, size);
290 ret = mhi_fw_load_sbl(mhi_cntrl, dma_addr, size);
291 mhi_free_coherent(mhi_cntrl, size, buf, dma_addr);
292
293 if (!mhi_cntrl->fbc_download || ret || mhi_cntrl->ee == MHI_EE_EDL)
294 release_firmware(firmware);
295
296 /* Error or in EDL mode, we're done */
297 if (ret || mhi_cntrl->ee == MHI_EE_EDL)
298 return;
299
300 write_lock_irq(&mhi_cntrl->pm_lock);
301 mhi_cntrl->dev_state = MHI_STATE_RESET;
302 write_unlock_irq(&mhi_cntrl->pm_lock);
303
304 /*
305 * If we're doing fbc, populate vector tables while
306 * device transitioning into MHI READY state
307 */
308 if (mhi_cntrl->fbc_download) {
309 ret = mhi_alloc_bhie_table(mhi_cntrl, &mhi_cntrl->fbc_image,
310 firmware->size);
311 if (ret)
312 goto error_alloc_fw_table;
313
314 /* Load the firmware into BHIE vec table */
315 mhi_firmware_copy(mhi_cntrl, firmware, mhi_cntrl->fbc_image);
316 }
317
318fw_load_ee_pthru:
319 /* Transitioning into MHI RESET->READY state */
320 ret = mhi_ready_state_transition(mhi_cntrl);
321
322 if (!mhi_cntrl->fbc_download)
323 return;
324
325 if (ret)
326 goto error_read;
327
328 /* Wait for the SBL event */
329 ret = wait_event_timeout(mhi_cntrl->state_event,
330 mhi_cntrl->ee == MHI_EE_SBL ||
331 MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state),
332 msecs_to_jiffies(mhi_cntrl->timeout_ms));
333
334 if (!ret || MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state)) {
335 dev_err(dev, "MHI did not enter SBL\n");
336 goto error_read;
337 }
338
339 /* Start full firmware image download */
340 image_info = mhi_cntrl->fbc_image;
341 ret = mhi_fw_load_amss(mhi_cntrl,
342 /* Vector table is the last entry */
343 &image_info->mhi_buf[image_info->entries - 1]);
344
345 release_firmware(firmware);
346
347 return;
348
349error_read:
350 mhi_free_bhie_table(mhi_cntrl, mhi_cntrl->fbc_image);
351 mhi_cntrl->fbc_image = NULL;
352
353error_alloc_fw_table:
354 release_firmware(firmware);
355}
drivers/bus/mhi/core/init.c+1−0
@@ -757,6 +757,7 @@ int mhi_register_controller(struct mhi_controller *mhi_cntrl, · 756 unmodified lines
757 spin_lock_init(&mhi_cntrl->wlock);757 spin_lock_init(&mhi_cntrl->wlock);
758 INIT_WORK(&mhi_cntrl->st_worker, mhi_pm_st_worker);758 INIT_WORK(&mhi_cntrl->st_worker, mhi_pm_st_worker);
759 INIT_WORK(&mhi_cntrl->syserr_worker, mhi_pm_sys_err_worker);759 INIT_WORK(&mhi_cntrl->syserr_worker, mhi_pm_sys_err_worker);
760 INIT_WORK(&mhi_cntrl->fw_worker, mhi_fw_load_worker);
760 init_waitqueue_head(&mhi_cntrl->state_event);761 init_waitqueue_head(&mhi_cntrl->state_event);
761 762
762 mhi_cmd = mhi_cntrl->mhi_cmd;763 mhi_cmd = mhi_cntrl->mhi_cmd;
drivers/bus/mhi/core/internal.h+1−0
@@ -578,6 +578,7 @@ int mhi_queue_state_transition(struct mhi_controller *mhi_cntrl, · 577 unmodified lines
578 enum dev_st_transition state);578 enum dev_st_transition state);
579void mhi_pm_st_worker(struct work_struct *work);579void mhi_pm_st_worker(struct work_struct *work);
580void mhi_pm_sys_err_worker(struct work_struct *work);580void mhi_pm_sys_err_worker(struct work_struct *work);
581void mhi_fw_load_worker(struct work_struct *work);
581int mhi_ready_state_transition(struct mhi_controller *mhi_cntrl);582int mhi_ready_state_transition(struct mhi_controller *mhi_cntrl);
582void mhi_ctrl_ev_task(unsigned long data);583void mhi_ctrl_ev_task(unsigned long data);
583int mhi_pm_m0_transition(struct mhi_controller *mhi_cntrl);584int mhi_pm_m0_transition(struct mhi_controller *mhi_cntrl);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t