1 /* arch/arm/mach-msm/qdsp5/adsp.c
3 * Register/Interrupt access for userspace aDSP library.
5 * Copyright (c) 2008 QUALCOMM Incorporated
6 * Copyright (C) 2008 Google, Inc.
7 * Author: Iliyan Malchev <ibm@android.com>
9 * This software is licensed under the terms of the GNU General Public
10 * License version 2, as published by the Free Software Foundation, and
11 * may be copied, distributed, and modified under those terms.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
21 * - move shareable rpc code outside of adsp.c
22 * - general solution for virt->phys patchup
23 * - queue IDs should be relative to modules
24 * - disallow access to non-associated queues
27 #include <linux/clk.h>
28 #include <linux/delay.h>
29 #include <linux/interrupt.h>
30 #include <linux/kernel.h>
31 #include <linux/kthread.h>
32 #include <linux/module.h>
33 #include <linux/slab.h>
34 #include <linux/uaccess.h>
35 #include <linux/wait.h>
37 static inline void prevent_suspend(void)
40 static inline void allow_suspend(void)
45 #include <mach/msm_iomap.h>
48 #define INT_ADSP INT_ADSP_A9_A11
50 static struct adsp_info adsp_info
;
51 static struct msm_rpc_endpoint
*rpc_cb_server_client
;
52 static struct msm_adsp_module
*adsp_modules
;
53 static int adsp_open_count
;
54 static DEFINE_MUTEX(adsp_open_lock
);
56 /* protect interactions with the ADSP command/message queue */
57 static spinlock_t adsp_cmd_lock
;
59 static uint32_t current_image
= -1;
61 void adsp_set_image(struct adsp_info
*info
, uint32_t image
)
63 current_image
= image
;
67 * Checks whether the module_id is available in the
68 * module_entries table.If module_id is available returns `0`.
69 * If module_id is not available returns `-ENXIO`.
71 #if CONFIG_MSM_AMSS_VERSION >= 6350
72 static int32_t adsp_validate_module(uint32_t module_id
)
75 uint32_t module_index
;
76 uint32_t num_mod_entries
;
78 ptr
= adsp_info
.init_info_ptr
->module_entries
;
79 num_mod_entries
= adsp_info
.init_info_ptr
->module_table_size
;
81 for (module_index
= 0; module_index
< num_mod_entries
; module_index
++)
82 if (module_id
== ptr
[module_index
])
88 static inline int32_t adsp_validate_module(uint32_t module_id
) { return 0; }
91 uint32_t adsp_get_module(struct adsp_info
*info
, uint32_t task
)
93 BUG_ON(current_image
== -1UL);
94 return info
->task_to_module
[current_image
][task
];
97 uint32_t adsp_get_queue_offset(struct adsp_info
*info
, uint32_t queue_id
)
99 BUG_ON(current_image
== -1UL);
100 return info
->queue_offset
[current_image
][queue_id
];
103 static int rpc_adsp_rtos_app_to_modem(uint32_t cmd
, uint32_t module
,
104 struct msm_adsp_module
*adsp_module
)
107 struct rpc_adsp_rtos_app_to_modem_args_t rpc_req
;
108 struct rpc_reply_hdr
*rpc_rsp
;
110 msm_rpc_setup_req(&rpc_req
.hdr
,
111 RPC_ADSP_RTOS_ATOM_PROG
,
112 msm_rpc_get_vers(adsp_module
->rpc_client
),
113 RPC_ADSP_RTOS_APP_TO_MODEM_PROC
);
115 rpc_req
.gotit
= cpu_to_be32(1);
116 rpc_req
.cmd
= cpu_to_be32(cmd
);
117 rpc_req
.proc_id
= cpu_to_be32(RPC_ADSP_RTOS_PROC_APPS
);
118 rpc_req
.module
= cpu_to_be32(module
);
119 rc
= msm_rpc_write(adsp_module
->rpc_client
, &rpc_req
, sizeof(rpc_req
));
121 pr_err("adsp: could not send RPC request: %d\n", rc
);
125 rc
= msm_rpc_read(adsp_module
->rpc_client
,
126 (void **)&rpc_rsp
, -1, (5*HZ
));
128 pr_err("adsp: error receiving RPC reply: %d (%d)\n",
133 if (be32_to_cpu(rpc_rsp
->reply_stat
) != RPCMSG_REPLYSTAT_ACCEPTED
) {
134 pr_err("adsp: RPC call was denied!\n");
139 if (be32_to_cpu(rpc_rsp
->data
.acc_hdr
.accept_stat
) !=
140 RPC_ACCEPTSTAT_SUCCESS
) {
141 pr_err("adsp error: RPC call was not successful (%d)\n",
142 be32_to_cpu(rpc_rsp
->data
.acc_hdr
.accept_stat
));
151 #if CONFIG_MSM_AMSS_VERSION >= 6350
152 static int get_module_index(uint32_t id
)
155 for (mod_idx
= 0; mod_idx
< adsp_info
.module_count
; mod_idx
++)
156 if (adsp_info
.module
[mod_idx
].id
== id
)
163 static struct msm_adsp_module
*find_adsp_module_by_id(
164 struct adsp_info
*info
, uint32_t id
)
166 if (id
> info
->max_module_id
) {
169 #if CONFIG_MSM_AMSS_VERSION >= 6350
170 id
= get_module_index(id
);
174 return info
->id_to_module
[id
];
178 static struct msm_adsp_module
*find_adsp_module_by_name(
179 struct adsp_info
*info
, const char *name
)
182 for (n
= 0; n
< info
->module_count
; n
++)
183 if (!strcmp(name
, adsp_modules
[n
].name
))
184 return adsp_modules
+ n
;
188 static int adsp_rpc_init(struct msm_adsp_module
*adsp_module
)
190 /* remove the original connect once compatible support is complete */
191 adsp_module
->rpc_client
= msm_rpc_connect(
192 RPC_ADSP_RTOS_ATOM_PROG
,
193 RPC_ADSP_RTOS_ATOM_VERS
,
194 MSM_RPC_UNINTERRUPTIBLE
);
196 if (IS_ERR(adsp_module
->rpc_client
)) {
197 int rc
= PTR_ERR(adsp_module
->rpc_client
);
198 adsp_module
->rpc_client
= 0;
199 pr_err("adsp: could not open rpc client: %d\n", rc
);
206 #if CONFIG_MSM_AMSS_VERSION >= 6350
208 * Send RPC_ADSP_RTOS_CMD_GET_INIT_INFO cmd to ARM9 and get
209 * queue offsets and module entries (init info) as part of the event.
211 static void msm_get_init_info(void)
214 struct rpc_adsp_rtos_app_to_modem_args_t rpc_req
;
216 adsp_info
.init_info_rpc_client
= msm_rpc_connect(
217 RPC_ADSP_RTOS_ATOM_PROG
,
218 RPC_ADSP_RTOS_ATOM_VERS
,
219 MSM_RPC_UNINTERRUPTIBLE
);
220 if (IS_ERR(adsp_info
.init_info_rpc_client
)) {
221 rc
= PTR_ERR(adsp_info
.init_info_rpc_client
);
222 adsp_info
.init_info_rpc_client
= 0;
223 pr_err("adsp: could not open rpc client: %d\n", rc
);
227 msm_rpc_setup_req(&rpc_req
.hdr
,
228 RPC_ADSP_RTOS_ATOM_PROG
,
229 msm_rpc_get_vers(adsp_info
.init_info_rpc_client
),
230 RPC_ADSP_RTOS_APP_TO_MODEM_PROC
);
232 rpc_req
.gotit
= cpu_to_be32(1);
233 rpc_req
.cmd
= cpu_to_be32(RPC_ADSP_RTOS_CMD_GET_INIT_INFO
);
234 rpc_req
.proc_id
= cpu_to_be32(RPC_ADSP_RTOS_PROC_APPS
);
237 rc
= msm_rpc_write(adsp_info
.init_info_rpc_client
,
238 &rpc_req
, sizeof(rpc_req
));
240 pr_err("adsp: could not send RPC request: %d\n", rc
);
244 int msm_adsp_get(const char *name
, struct msm_adsp_module
**out
,
245 struct msm_adsp_ops
*ops
, void *driver_data
)
247 struct msm_adsp_module
*module
;
250 #if CONFIG_MSM_AMSS_VERSION >= 6350
251 static uint32_t init_info_cmd_sent
;
252 if (!init_info_cmd_sent
) {
254 init_waitqueue_head(&adsp_info
.init_info_wait
);
255 rc
= wait_event_timeout(adsp_info
.init_info_wait
,
256 adsp_info
.init_info_state
== ADSP_STATE_INIT_INFO
,
259 pr_info("adsp: INIT_INFO failed\n");
262 init_info_cmd_sent
++;
266 module
= find_adsp_module_by_name(&adsp_info
, name
);
270 mutex_lock(&module
->lock
);
271 pr_info("adsp: opening module %s\n", module
->name
);
272 if (module
->open_count
++ == 0 && module
->clk
)
273 clk_enable(module
->clk
);
275 mutex_lock(&adsp_open_lock
);
276 if (adsp_open_count
++ == 0) {
277 enable_irq(INT_ADSP
);
280 mutex_unlock(&adsp_open_lock
);
287 rc
= adsp_rpc_init(module
);
292 module
->driver_data
= driver_data
;
294 rc
= rpc_adsp_rtos_app_to_modem(RPC_ADSP_RTOS_CMD_REGISTER_APP
,
298 module
->driver_data
= NULL
;
300 pr_err("adsp: REGISTER_APP failed\n");
304 pr_info("adsp: module %s has been registered\n", module
->name
);
307 mutex_lock(&adsp_open_lock
);
308 if (rc
&& --adsp_open_count
== 0) {
309 disable_irq(INT_ADSP
);
312 if (rc
&& --module
->open_count
== 0 && module
->clk
)
313 clk_disable(module
->clk
);
314 mutex_unlock(&adsp_open_lock
);
315 mutex_unlock(&module
->lock
);
318 EXPORT_SYMBOL(msm_adsp_get
);
320 static int msm_adsp_disable_locked(struct msm_adsp_module
*module
);
322 void msm_adsp_put(struct msm_adsp_module
*module
)
326 mutex_lock(&module
->lock
);
327 if (--module
->open_count
== 0 && module
->clk
)
328 clk_disable(module
->clk
);
330 pr_info("adsp: closing module %s\n", module
->name
);
332 /* lock to ensure a dsp event cannot be delivered
333 * during or after removal of the ops and driver_data
335 spin_lock_irqsave(&adsp_cmd_lock
, flags
);
337 module
->driver_data
= NULL
;
338 spin_unlock_irqrestore(&adsp_cmd_lock
, flags
);
340 if (module
->state
!= ADSP_STATE_DISABLED
) {
341 pr_info("adsp: disabling module %s\n", module
->name
);
342 msm_adsp_disable_locked(module
);
345 msm_rpc_close(module
->rpc_client
);
346 module
->rpc_client
= 0;
347 if (--adsp_open_count
== 0) {
348 disable_irq(INT_ADSP
);
350 pr_info("adsp: disable interrupt\n");
353 pr_info("adsp: module %s is already closed\n", module
->name
);
355 mutex_unlock(&module
->lock
);
357 EXPORT_SYMBOL(msm_adsp_put
);
359 /* this should be common code with rpc_servers.c */
360 static int rpc_send_accepted_void_reply(struct msm_rpc_endpoint
*client
,
361 uint32_t xid
, uint32_t accept_status
)
364 uint8_t reply_buf
[sizeof(struct rpc_reply_hdr
)];
365 struct rpc_reply_hdr
*reply
= (struct rpc_reply_hdr
*)reply_buf
;
367 reply
->xid
= cpu_to_be32(xid
);
368 reply
->type
= cpu_to_be32(1); /* reply */
369 reply
->reply_stat
= cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED
);
371 reply
->data
.acc_hdr
.accept_stat
= cpu_to_be32(accept_status
);
372 reply
->data
.acc_hdr
.verf_flavor
= 0;
373 reply
->data
.acc_hdr
.verf_length
= 0;
375 rc
= msm_rpc_write(rpc_cb_server_client
, reply_buf
, sizeof(reply_buf
));
377 pr_err("adsp: could not write RPC response: %d\n", rc
);
381 int __msm_adsp_write(struct msm_adsp_module
*module
, unsigned dsp_queue_addr
,
382 void *cmd_buf
, size_t cmd_size
)
391 struct adsp_info
*info
= module
->info
;
393 spin_lock_irqsave(&adsp_cmd_lock
, flags
);
395 if (module
->state
!= ADSP_STATE_ENABLED
) {
396 spin_unlock_irqrestore(&adsp_cmd_lock
, flags
);
397 pr_err("adsp: module %s not enabled before write\n",
401 if (adsp_validate_module(module
->id
)) {
402 spin_unlock_irqrestore(&adsp_cmd_lock
, flags
);
403 pr_info("adsp: module id validation failed %s %d\n",
404 module
->name
, module
->id
);
407 dsp_q_addr
= adsp_get_queue_offset(info
, dsp_queue_addr
);
408 dsp_q_addr
&= ADSP_RTOS_WRITE_CTRL_WORD_DSP_ADDR_M
;
410 /* Poll until the ADSP is ready to accept a command.
411 * Wait for 100us, return error if it's not responding.
412 * If this returns an error, we need to disable ALL modules and
415 while (((ctrl_word
= readl(info
->write_ctrl
)) &
416 ADSP_RTOS_WRITE_CTRL_WORD_READY_M
) !=
417 ADSP_RTOS_WRITE_CTRL_WORD_READY_V
) {
419 pr_err("adsp: timeout waiting for DSP write ready\n");
423 pr_warning("adsp: waiting for DSP write ready\n");
428 /* Set the mutex bits */
429 ctrl_word
&= ~(ADSP_RTOS_WRITE_CTRL_WORD_MUTEX_M
);
430 ctrl_word
|= ADSP_RTOS_WRITE_CTRL_WORD_MUTEX_NAVAIL_V
;
432 /* Clear the command bits */
433 ctrl_word
&= ~(ADSP_RTOS_WRITE_CTRL_WORD_CMD_M
);
435 /* Set the queue address bits */
436 ctrl_word
&= ~(ADSP_RTOS_WRITE_CTRL_WORD_DSP_ADDR_M
);
437 ctrl_word
|= dsp_q_addr
;
439 writel(ctrl_word
, info
->write_ctrl
);
441 /* Generate an interrupt to the DSP. This notifies the DSP that
442 * we are about to send a command on this particular queue. The
443 * DSP will in response change its state.
445 writel(1, info
->send_irq
);
447 /* Poll until the adsp responds to the interrupt; this does not
448 * generate an interrupt from the adsp. This should happen within
452 while ((readl(info
->write_ctrl
) &
453 ADSP_RTOS_WRITE_CTRL_WORD_MUTEX_M
) ==
454 ADSP_RTOS_WRITE_CTRL_WORD_MUTEX_NAVAIL_V
) {
456 pr_err("adsp: timeout waiting for adsp ack\n");
464 /* Read the ctrl word */
465 ctrl_word
= readl(info
->write_ctrl
);
467 if ((ctrl_word
& ADSP_RTOS_WRITE_CTRL_WORD_STATUS_M
) !=
468 ADSP_RTOS_WRITE_CTRL_WORD_NO_ERR_V
) {
469 ret_status
= -EAGAIN
;
473 /* Ctrl word status bits were 00, no error in the ctrl word */
475 /* Get the DSP buffer address */
476 dsp_addr
= (ctrl_word
& ADSP_RTOS_WRITE_CTRL_WORD_DSP_ADDR_M
) +
477 (uint32_t)MSM_AD5_BASE
;
479 if (dsp_addr
< (uint32_t)(MSM_AD5_BASE
+ QDSP_RAMC_OFFSET
)) {
480 uint16_t *buf_ptr
= (uint16_t *) cmd_buf
;
481 uint16_t *dsp_addr16
= (uint16_t *)dsp_addr
;
482 cmd_size
/= sizeof(uint16_t);
484 /* Save the command ID */
485 cmd_id
= (uint32_t) buf_ptr
[0];
487 /* Copy the command to DSP memory */
490 *dsp_addr16
++ = *buf_ptr
++;
492 uint32_t *buf_ptr
= (uint32_t *) cmd_buf
;
493 uint32_t *dsp_addr32
= (uint32_t *)dsp_addr
;
494 cmd_size
/= sizeof(uint32_t);
496 /* Save the command ID */
501 *dsp_addr32
++ = *buf_ptr
++;
504 /* Set the mutex bits */
505 ctrl_word
&= ~(ADSP_RTOS_WRITE_CTRL_WORD_MUTEX_M
);
506 ctrl_word
|= ADSP_RTOS_WRITE_CTRL_WORD_MUTEX_NAVAIL_V
;
508 /* Set the command bits to write done */
509 ctrl_word
&= ~(ADSP_RTOS_WRITE_CTRL_WORD_CMD_M
);
510 ctrl_word
|= ADSP_RTOS_WRITE_CTRL_WORD_CMD_WRITE_DONE_V
;
512 /* Set the queue address bits */
513 ctrl_word
&= ~(ADSP_RTOS_WRITE_CTRL_WORD_DSP_ADDR_M
);
514 ctrl_word
|= dsp_q_addr
;
516 writel(ctrl_word
, info
->write_ctrl
);
518 /* Generate an interrupt to the DSP. It does not respond with
519 * an interrupt, and we do not need to wait for it to
520 * acknowledge, because it will hold the mutex lock until it's
521 * ready to receive more commands again.
523 writel(1, info
->send_irq
);
525 module
->num_commands
++;
528 spin_unlock_irqrestore(&adsp_cmd_lock
, flags
);
531 EXPORT_SYMBOL(msm_adsp_write
);
533 int msm_adsp_write(struct msm_adsp_module
*module
, unsigned dsp_queue_addr
,
534 void *cmd_buf
, size_t cmd_size
)
538 rc
= __msm_adsp_write(module
, dsp_queue_addr
, cmd_buf
, cmd_size
);
541 } while(rc
== -EAGAIN
&& retries
++ < 100);
543 pr_warning("adsp: %s command took %d attempts: rc %d\n",
544 module
->name
, retries
, rc
);
548 #ifdef CONFIG_MSM_ADSP_REPORT_EVENTS
549 static void *modem_event_addr
;
550 #if CONFIG_MSM_AMSS_VERSION >= 6350
551 static void read_modem_event(void *buf
, size_t len
)
553 uint32_t *dptr
= buf
;
554 struct rpc_adsp_rtos_modem_to_app_args_t
*sptr
;
555 struct adsp_rtos_mp_mtoa_type
*pkt_ptr
;
557 sptr
= modem_event_addr
;
558 pkt_ptr
= &sptr
->mtoa_pkt
.adsp_rtos_mp_mtoa_data
.mp_mtoa_packet
;
560 dptr
[0] = be32_to_cpu(sptr
->mtoa_pkt
.mp_mtoa_header
.event
);
561 dptr
[1] = be32_to_cpu(pkt_ptr
->module
);
562 dptr
[2] = be32_to_cpu(pkt_ptr
->image
);
565 static void read_modem_event(void *buf
, size_t len
)
567 uint32_t *dptr
= buf
;
568 struct rpc_adsp_rtos_modem_to_app_args_t
*sptr
=
570 dptr
[0] = be32_to_cpu(sptr
->event
);
571 dptr
[1] = be32_to_cpu(sptr
->module
);
572 dptr
[2] = be32_to_cpu(sptr
->image
);
574 #endif /* CONFIG_MSM_AMSS_VERSION >= 6350 */
575 #endif /* CONFIG_MSM_ADSP_REPORT_EVENTS */
577 static void handle_adsp_rtos_mtoa_app(struct rpc_request_hdr
*req
)
579 struct rpc_adsp_rtos_modem_to_app_args_t
*args
=
580 (struct rpc_adsp_rtos_modem_to_app_args_t
*)req
;
585 struct msm_adsp_module
*module
;
586 #if CONFIG_MSM_AMSS_VERSION >= 6350
587 struct adsp_rtos_mp_mtoa_type
*pkt_ptr
=
588 &args
->mtoa_pkt
.adsp_rtos_mp_mtoa_data
.mp_mtoa_packet
;
590 event
= be32_to_cpu(args
->mtoa_pkt
.mp_mtoa_header
.event
);
591 proc_id
= be32_to_cpu(args
->mtoa_pkt
.mp_mtoa_header
.proc_id
);
592 module_id
= be32_to_cpu(pkt_ptr
->module
);
593 image
= be32_to_cpu(pkt_ptr
->image
);
595 if (be32_to_cpu(args
->mtoa_pkt
.desc_field
) == RPC_ADSP_RTOS_INIT_INFO
) {
596 struct queue_to_offset_type
*qptr
;
597 struct queue_to_offset_type
*qtbl
;
601 uint32_t num_entries
;
602 uint32_t entries_per_image
;
603 struct adsp_rtos_mp_mtoa_init_info_type
*iptr
;
604 struct adsp_rtos_mp_mtoa_init_info_type
*sptr
;
607 pr_info("adsp:INIT_INFO Event\n");
608 sptr
= &args
->mtoa_pkt
.adsp_rtos_mp_mtoa_data
.
611 iptr
= adsp_info
.init_info_ptr
;
612 iptr
->image_count
= be32_to_cpu(sptr
->image_count
);
613 iptr
->num_queue_offsets
= be32_to_cpu(sptr
->num_queue_offsets
);
614 num_entries
= iptr
->num_queue_offsets
;
615 qptr
= &sptr
->queue_offsets_tbl
[0][0];
616 for (i_no
= 0; i_no
< iptr
->image_count
; i_no
++) {
617 qtbl
= &iptr
->queue_offsets_tbl
[i_no
][0];
618 for (e_idx
= 0; e_idx
< num_entries
; e_idx
++) {
619 qtbl
[e_idx
].offset
= be32_to_cpu(qptr
->offset
);
620 qtbl
[e_idx
].queue
= be32_to_cpu(qptr
->queue
);
621 q_idx
= be32_to_cpu(qptr
->queue
);
622 iptr
->queue_offsets
[i_no
][q_idx
] =
628 num_entries
= be32_to_cpu(sptr
->num_task_module_entries
);
629 iptr
->num_task_module_entries
= num_entries
;
630 entries_per_image
= num_entries
/ iptr
->image_count
;
631 mptr
= &sptr
->task_to_module_tbl
[0][0];
632 for (i_no
= 0; i_no
< iptr
->image_count
; i_no
++) {
633 mtbl
= &iptr
->task_to_module_tbl
[i_no
][0];
634 for (e_idx
= 0; e_idx
< entries_per_image
; e_idx
++) {
635 mtbl
[e_idx
] = be32_to_cpu(*mptr
);
640 iptr
->module_table_size
= be32_to_cpu(sptr
->module_table_size
);
641 mptr
= &sptr
->module_entries
[0];
642 for (i_no
= 0; i_no
< iptr
->module_table_size
; i_no
++)
643 iptr
->module_entries
[i_no
] = be32_to_cpu(mptr
[i_no
]);
644 adsp_info
.init_info_state
= ADSP_STATE_INIT_INFO
;
645 rpc_send_accepted_void_reply(rpc_cb_server_client
, req
->xid
,
646 RPC_ACCEPTSTAT_SUCCESS
);
647 wake_up(&adsp_info
.init_info_wait
);
652 event
= be32_to_cpu(args
->event
);
653 proc_id
= be32_to_cpu(args
->proc_id
);
654 module_id
= be32_to_cpu(args
->module
);
655 image
= be32_to_cpu(args
->image
);
658 pr_info("adsp: rpc event=%d, proc_id=%d, module=%d, image=%d\n",
659 event
, proc_id
, module_id
, image
);
661 module
= find_adsp_module_by_id(&adsp_info
, module_id
);
663 pr_err("adsp: module %d is not supported!\n", module_id
);
664 rpc_send_accepted_void_reply(rpc_cb_server_client
, req
->xid
,
665 RPC_ACCEPTSTAT_GARBAGE_ARGS
);
669 mutex_lock(&module
->lock
);
671 case RPC_ADSP_RTOS_MOD_READY
:
672 pr_info("adsp: module %s: READY\n", module
->name
);
673 module
->state
= ADSP_STATE_ENABLED
;
674 wake_up(&module
->state_wait
);
675 adsp_set_image(module
->info
, image
);
677 case RPC_ADSP_RTOS_MOD_DISABLE
:
678 pr_info("adsp: module %s: DISABLED\n", module
->name
);
679 module
->state
= ADSP_STATE_DISABLED
;
680 wake_up(&module
->state_wait
);
682 case RPC_ADSP_RTOS_SERVICE_RESET
:
683 pr_info("adsp: module %s: SERVICE_RESET\n", module
->name
);
684 module
->state
= ADSP_STATE_DISABLED
;
685 wake_up(&module
->state_wait
);
687 case RPC_ADSP_RTOS_CMD_SUCCESS
:
688 pr_info("adsp: module %s: CMD_SUCCESS\n", module
->name
);
690 case RPC_ADSP_RTOS_CMD_FAIL
:
691 pr_info("adsp: module %s: CMD_FAIL\n", module
->name
);
693 #if CONFIG_MSM_AMSS_VERSION >= 6350
694 case RPC_ADSP_RTOS_DISABLE_FAIL
:
695 pr_info("adsp: module %s: DISABLE_FAIL\n", module
->name
);
699 pr_info("adsp: unknown event %d\n", event
);
700 rpc_send_accepted_void_reply(rpc_cb_server_client
, req
->xid
,
701 RPC_ACCEPTSTAT_GARBAGE_ARGS
);
702 mutex_unlock(&module
->lock
);
705 rpc_send_accepted_void_reply(rpc_cb_server_client
, req
->xid
,
706 RPC_ACCEPTSTAT_SUCCESS
);
707 mutex_unlock(&module
->lock
);
708 #ifdef CONFIG_MSM_ADSP_REPORT_EVENTS
709 modem_event_addr
= (uint32_t *)req
;
710 module
->ops
->event(module
->driver_data
, EVENT_MSG_ID
,
711 EVENT_LEN
, read_modem_event
);
715 static int handle_adsp_rtos_mtoa(struct rpc_request_hdr
*req
)
717 switch (req
->procedure
) {
718 case RPC_ADSP_RTOS_MTOA_NULL_PROC
:
719 rpc_send_accepted_void_reply(rpc_cb_server_client
,
721 RPC_ACCEPTSTAT_SUCCESS
);
723 case RPC_ADSP_RTOS_MODEM_TO_APP_PROC
:
724 handle_adsp_rtos_mtoa_app(req
);
727 pr_err("adsp: unknowned proc %d\n", req
->procedure
);
728 rpc_send_accepted_void_reply(
729 rpc_cb_server_client
, req
->xid
,
730 RPC_ACCEPTSTAT_PROC_UNAVAIL
);
736 /* this should be common code with rpc_servers.c */
737 static int adsp_rpc_thread(void *data
)
740 struct rpc_request_hdr
*req
;
744 rc
= msm_rpc_read(rpc_cb_server_client
, &buffer
, -1, -1);
746 pr_err("adsp: could not read rpc: %d\n", rc
);
749 req
= (struct rpc_request_hdr
*)buffer
;
751 req
->type
= be32_to_cpu(req
->type
);
752 req
->xid
= be32_to_cpu(req
->xid
);
753 req
->rpc_vers
= be32_to_cpu(req
->rpc_vers
);
754 req
->prog
= be32_to_cpu(req
->prog
);
755 req
->vers
= be32_to_cpu(req
->vers
);
756 req
->procedure
= be32_to_cpu(req
->procedure
);
760 if (req
->rpc_vers
!= 2)
762 if (req
->prog
!= RPC_ADSP_RTOS_MTOA_PROG
)
764 if (req
->vers
!= RPC_ADSP_RTOS_MTOA_VERS
)
767 handle_adsp_rtos_mtoa(req
);
772 pr_err("adsp: bogus rpc from modem\n");
779 static size_t read_event_size
;
780 static void *read_event_addr
;
782 static void read_event_16(void *buf
, size_t len
)
785 uint16_t *src
= read_event_addr
;
787 if (len
> read_event_size
)
788 len
= read_event_size
;
793 static void read_event_32(void *buf
, size_t len
)
796 uint32_t *src
= read_event_addr
;
798 if (len
> read_event_size
)
799 len
= read_event_size
;
804 static int adsp_rtos_read_ctrl_word_cmd_tast_to_h_v(
805 struct adsp_info
*info
, void *dsp_addr
)
807 struct msm_adsp_module
*module
;
808 unsigned rtos_task_id
;
811 void (*func
)(void *, size_t);
813 if (dsp_addr
>= (void *)(MSM_AD5_BASE
+ QDSP_RAMC_OFFSET
)) {
814 uint32_t *dsp_addr32
= dsp_addr
;
815 uint32_t tmp
= *dsp_addr32
++;
816 rtos_task_id
= (tmp
& ADSP_RTOS_READ_CTRL_WORD_TASK_ID_M
) >> 8;
817 msg_id
= (tmp
& ADSP_RTOS_READ_CTRL_WORD_MSG_ID_M
);
818 read_event_size
= tmp
>> 16;
819 read_event_addr
= dsp_addr32
;
820 msg_length
= read_event_size
* sizeof(uint32_t);
821 func
= read_event_32
;
823 uint16_t *dsp_addr16
= dsp_addr
;
824 uint16_t tmp
= *dsp_addr16
++;
825 rtos_task_id
= (tmp
& ADSP_RTOS_READ_CTRL_WORD_TASK_ID_M
) >> 8;
826 msg_id
= tmp
& ADSP_RTOS_READ_CTRL_WORD_MSG_ID_M
;
827 read_event_size
= *dsp_addr16
++;
828 read_event_addr
= dsp_addr16
;
829 msg_length
= read_event_size
* sizeof(uint16_t);
830 func
= read_event_16
;
833 if (rtos_task_id
> info
->max_task_id
) {
834 pr_err("adsp: bogus task id %d\n", rtos_task_id
);
837 module
= find_adsp_module_by_id(info
,
838 adsp_get_module(info
, rtos_task_id
));
841 pr_err("adsp: no module for task id %d\n", rtos_task_id
);
845 module
->num_events
++;
848 pr_err("adsp: module %s is not open\n", module
->name
);
852 module
->ops
->event(module
->driver_data
, msg_id
, msg_length
, func
);
856 static int adsp_get_event(struct adsp_info
*info
)
866 spin_lock_irqsave(&adsp_cmd_lock
, flags
);
868 /* Whenever the DSP has a message, it updates this control word
869 * and generates an interrupt. When we receive the interrupt, we
870 * read this register to find out what ADSP task the command is
873 * The ADSP should *always* be ready on the first call, but the
874 * irq handler calls us in a loop (to handle back-to-back command
875 * processing), so we give the DSP some time to return to the
876 * ready state. The DSP will not issue another IRQ for events
877 * pending between the first IRQ and the event queue being drained,
881 for (cnt
= 0; cnt
< 10; cnt
++) {
882 ctrl_word
= readl(info
->read_ctrl
);
884 if ((ctrl_word
& ADSP_RTOS_READ_CTRL_WORD_FLAG_M
) ==
885 ADSP_RTOS_READ_CTRL_WORD_FLAG_UP_CONT_V
)
890 pr_warning("adsp: not ready after 100uS\n");
895 /* Here we check to see if there are pending messages. If there are
896 * none, we siply return -EAGAIN to indicate that there are no more
899 ready
= ctrl_word
& ADSP_RTOS_READ_CTRL_WORD_READY_M
;
900 if ((ready
!= ADSP_RTOS_READ_CTRL_WORD_READY_V
) &&
901 (ready
!= ADSP_RTOS_READ_CTRL_WORD_CONT_V
)) {
906 /* DSP says that there are messages waiting for the host to read */
908 /* Get the Command Type */
909 cmd_type
= ctrl_word
& ADSP_RTOS_READ_CTRL_WORD_CMD_TYPE_M
;
911 /* Get the DSP buffer address */
912 dsp_addr
= (void *)((ctrl_word
&
913 ADSP_RTOS_READ_CTRL_WORD_DSP_ADDR_M
) +
914 (uint32_t)MSM_AD5_BASE
);
916 /* We can only handle Task-to-Host messages */
917 if (cmd_type
!= ADSP_RTOS_READ_CTRL_WORD_CMD_TASK_TO_H_V
) {
918 pr_err("adsp: unknown dsp cmd_type %d\n", cmd_type
);
923 adsp_rtos_read_ctrl_word_cmd_tast_to_h_v(info
, dsp_addr
);
925 ctrl_word
= readl(info
->read_ctrl
);
926 ctrl_word
&= ~ADSP_RTOS_READ_CTRL_WORD_READY_M
;
928 /* Write ctrl word to the DSP */
929 writel(ctrl_word
, info
->read_ctrl
);
931 /* Generate an interrupt to the DSP */
932 writel(1, info
->send_irq
);
935 spin_unlock_irqrestore(&adsp_cmd_lock
, flags
);
939 static irqreturn_t
adsp_irq_handler(int irq
, void *data
)
941 struct adsp_info
*info
= &adsp_info
;
943 for (cnt
= 0; cnt
< 10; cnt
++)
944 if (adsp_get_event(info
) < 0)
946 if (cnt
> info
->event_backlog_max
)
947 info
->event_backlog_max
= cnt
;
948 info
->events_received
+= cnt
;
950 pr_err("adsp: too many (%d) events for single irq!\n", cnt
);
954 int adsp_set_clkrate(struct msm_adsp_module
*module
, unsigned long clk_rate
)
956 if (module
->clk
&& clk_rate
)
957 return clk_set_rate(module
->clk
, clk_rate
);
962 int msm_adsp_enable(struct msm_adsp_module
*module
)
966 pr_info("msm_adsp_enable() '%s'state[%d] id[%d]\n",
967 module
->name
, module
->state
, module
->id
);
969 mutex_lock(&module
->lock
);
970 switch (module
->state
) {
971 case ADSP_STATE_DISABLED
:
972 rc
= rpc_adsp_rtos_app_to_modem(RPC_ADSP_RTOS_CMD_ENABLE
,
976 module
->state
= ADSP_STATE_ENABLING
;
977 mutex_unlock(&module
->lock
);
978 rc
= wait_event_timeout(module
->state_wait
,
979 module
->state
!= ADSP_STATE_ENABLING
,
981 mutex_lock(&module
->lock
);
982 if (module
->state
== ADSP_STATE_ENABLED
) {
985 pr_err("adsp: module '%s' enable timed out\n",
990 case ADSP_STATE_ENABLING
:
991 pr_warning("adsp: module '%s' enable in progress\n",
994 case ADSP_STATE_ENABLED
:
995 pr_warning("adsp: module '%s' already enabled\n",
998 case ADSP_STATE_DISABLING
:
999 pr_err("adsp: module '%s' disable in progress\n",
1004 mutex_unlock(&module
->lock
);
1007 EXPORT_SYMBOL(msm_adsp_enable
);
1009 static int msm_adsp_disable_locked(struct msm_adsp_module
*module
)
1013 switch (module
->state
) {
1014 case ADSP_STATE_DISABLED
:
1015 pr_warning("adsp: module '%s' already disabled\n",
1018 case ADSP_STATE_ENABLING
:
1019 case ADSP_STATE_ENABLED
:
1020 rc
= rpc_adsp_rtos_app_to_modem(RPC_ADSP_RTOS_CMD_DISABLE
,
1021 module
->id
, module
);
1022 module
->state
= ADSP_STATE_DISABLED
;
1027 int msm_adsp_disable(struct msm_adsp_module
*module
)
1030 pr_info("msm_adsp_disable() '%s'\n", module
->name
);
1031 mutex_lock(&module
->lock
);
1032 rc
= msm_adsp_disable_locked(module
);
1033 mutex_unlock(&module
->lock
);
1036 EXPORT_SYMBOL(msm_adsp_disable
);
1038 static int msm_adsp_probe(struct platform_device
*pdev
)
1044 pr_info("adsp: probe\n");
1046 #if CONFIG_MSM_AMSS_VERSION >= 6350
1047 adsp_info
.init_info_ptr
= kzalloc(
1048 (sizeof(struct adsp_rtos_mp_mtoa_init_info_type
)), GFP_KERNEL
);
1049 if (!adsp_info
.init_info_ptr
)
1053 rc
= adsp_init_info(&adsp_info
);
1056 adsp_info
.send_irq
+= (uint32_t) MSM_AD5_BASE
;
1057 adsp_info
.read_ctrl
+= (uint32_t) MSM_AD5_BASE
;
1058 adsp_info
.write_ctrl
+= (uint32_t) MSM_AD5_BASE
;
1059 count
= adsp_info
.module_count
;
1061 #if CONFIG_MSM_AMSS_VERSION >= 6350
1062 max_module_id
= count
;
1064 max_module_id
= adsp_info
.max_module_id
+ 1;
1067 adsp_modules
= kzalloc(
1068 sizeof(struct msm_adsp_module
) * count
+
1069 sizeof(void *) * max_module_id
, GFP_KERNEL
);
1073 adsp_info
.id_to_module
= (void *) (adsp_modules
+ count
);
1075 spin_lock_init(&adsp_cmd_lock
);
1077 rc
= request_irq(INT_ADSP
, adsp_irq_handler
, IRQF_TRIGGER_RISING
,
1080 goto fail_request_irq
;
1081 disable_irq(INT_ADSP
);
1083 rpc_cb_server_client
= msm_rpc_open();
1084 if (IS_ERR(rpc_cb_server_client
)) {
1085 rpc_cb_server_client
= NULL
;
1086 rc
= PTR_ERR(rpc_cb_server_client
);
1087 pr_err("adsp: could not create rpc server (%d)\n", rc
);
1091 rc
= msm_rpc_register_server(rpc_cb_server_client
,
1092 RPC_ADSP_RTOS_MTOA_PROG
,
1093 RPC_ADSP_RTOS_MTOA_VERS
);
1095 pr_err("adsp: could not register callback server (%d)\n", rc
);
1096 goto fail_rpc_register
;
1099 /* start the kernel thread to process the callbacks */
1100 kthread_run(adsp_rpc_thread
, NULL
, "kadspd");
1102 for (i
= 0; i
< count
; i
++) {
1103 struct msm_adsp_module
*mod
= adsp_modules
+ i
;
1104 mutex_init(&mod
->lock
);
1105 init_waitqueue_head(&mod
->state_wait
);
1106 mod
->info
= &adsp_info
;
1107 mod
->name
= adsp_info
.module
[i
].name
;
1108 mod
->id
= adsp_info
.module
[i
].id
;
1109 if (adsp_info
.module
[i
].clk_name
)
1110 mod
->clk
= clk_get(NULL
, adsp_info
.module
[i
].clk_name
);
1113 if (mod
->clk
&& adsp_info
.module
[i
].clk_rate
)
1114 clk_set_rate(mod
->clk
, adsp_info
.module
[i
].clk_rate
);
1115 mod
->verify_cmd
= adsp_info
.module
[i
].verify_cmd
;
1116 mod
->patch_event
= adsp_info
.module
[i
].patch_event
;
1117 INIT_HLIST_HEAD(&mod
->pmem_regions
);
1118 mod
->pdev
.name
= adsp_info
.module
[i
].pdev_name
;
1120 #if CONFIG_MSM_AMSS_VERSION >= 6350
1121 adsp_info
.id_to_module
[i
] = mod
;
1123 adsp_info
.id_to_module
[mod
->id
] = mod
;
1125 platform_device_register(&mod
->pdev
);
1128 msm_adsp_publish_cdevs(adsp_modules
, count
);
1133 msm_rpc_close(rpc_cb_server_client
);
1134 rpc_cb_server_client
= NULL
;
1136 enable_irq(INT_ADSP
);
1137 free_irq(INT_ADSP
, 0);
1139 kfree(adsp_modules
);
1140 #if CONFIG_MSM_AMSS_VERSION >= 6350
1141 kfree(adsp_info
.init_info_ptr
);
1146 static struct platform_driver msm_adsp_driver
= {
1147 .probe
= msm_adsp_probe
,
1149 .name
= MSM_ADSP_DRIVER_NAME
,
1150 .owner
= THIS_MODULE
,
1154 static int __init
adsp_init(void)
1156 return platform_driver_register(&msm_adsp_driver
);
1159 device_initcall(adsp_init
);