1 /* arch/arm/mach-msm/smd.c
3 * Copyright (C) 2007 Google, Inc.
4 * Author: Brian Swetland <swetland@google.com>
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 #include <linux/platform_device.h>
20 #include <linux/module.h>
22 #include <linux/cdev.h>
23 #include <linux/device.h>
24 #include <linux/wait.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/list.h>
28 #include <linux/slab.h>
29 #include <linux/debugfs.h>
30 #include <linux/delay.h>
32 #include <mach/msm_smd.h>
34 #include "smd_private.h"
35 #include "proc_comm.h"
37 #if defined(CONFIG_ARCH_QSD8X50)
38 #define CONFIG_QDSP6 1
41 #define MODULE_NAME "msm_smd"
44 MSM_SMD_DEBUG
= 1U << 0,
45 MSM_SMSM_DEBUG
= 1U << 0,
48 static int msm_smd_debug_mask
;
55 static unsigned dummy_state
[SMSM_STATE_COUNT
];
57 static struct shared_info smd_info
= {
58 /* FIXME: not a real __iomem pointer */
59 .state
= &dummy_state
,
62 module_param_named(debug_mask
, msm_smd_debug_mask
,
63 int, S_IRUGO
| S_IWUSR
| S_IWGRP
);
65 static unsigned last_heap_free
= 0xffffffff;
67 static inline void notify_other_smsm(void)
75 static inline void notify_modem_smd(void)
80 static inline void notify_dsp_smd(void)
85 static void smd_diag(void)
89 x
= smem_find(ID_DIAG_ERR_MSG
, SZ_DIAG_ERR_MSG
);
91 x
[SZ_DIAG_ERR_MSG
- 1] = 0;
92 pr_debug("DIAG '%s'\n", x
);
96 /* call when SMSM_RESET flag is set in the A9's smsm_state */
97 static void handle_modem_crash(void)
99 pr_err("ARM9 has CRASHED\n");
102 /* in this case the modem or watchdog should reboot us */
107 uint32_t raw_smsm_get_state(enum smsm_state_item item
)
109 return readl(smd_info
.state
+ item
* 4);
112 static int check_for_modem_crash(void)
114 if (raw_smsm_get_state(SMSM_STATE_MODEM
) & SMSM_RESET
) {
115 handle_modem_crash();
121 /* the spinlock is used to synchronize between the
122 * irq handler and code that mutates the channel
123 * list or fiddles with channel state
125 DEFINE_SPINLOCK(smd_lock
);
126 DEFINE_SPINLOCK(smem_lock
);
128 /* the mutex is used during open() and close()
129 * operations to avoid races while creating or
130 * destroying smd_channel structures
132 static DEFINE_MUTEX(smd_creation_mutex
);
134 static int smd_initialized
;
136 LIST_HEAD(smd_ch_closed_list
);
137 LIST_HEAD(smd_ch_list_modem
);
138 LIST_HEAD(smd_ch_list_dsp
);
140 static unsigned char smd_ch_allocated
[64];
141 static struct work_struct probe_work
;
143 /* how many bytes are available for reading */
144 static int smd_stream_read_avail(struct smd_channel
*ch
)
146 return (ch
->recv
->head
- ch
->recv
->tail
) & ch
->fifo_mask
;
149 /* how many bytes we are free to write */
150 static int smd_stream_write_avail(struct smd_channel
*ch
)
152 return ch
->fifo_mask
-
153 ((ch
->send
->head
- ch
->send
->tail
) & ch
->fifo_mask
);
156 static int smd_packet_read_avail(struct smd_channel
*ch
)
158 if (ch
->current_packet
) {
159 int n
= smd_stream_read_avail(ch
);
160 if (n
> ch
->current_packet
)
161 n
= ch
->current_packet
;
168 static int smd_packet_write_avail(struct smd_channel
*ch
)
170 int n
= smd_stream_write_avail(ch
);
171 return n
> SMD_HEADER_SIZE
? n
- SMD_HEADER_SIZE
: 0;
174 static int ch_is_open(struct smd_channel
*ch
)
176 return (ch
->recv
->state
== SMD_SS_OPENED
) &&
177 (ch
->send
->state
== SMD_SS_OPENED
);
180 /* provide a pointer and length to readable data in the fifo */
181 static unsigned ch_read_buffer(struct smd_channel
*ch
, void **ptr
)
183 unsigned head
= ch
->recv
->head
;
184 unsigned tail
= ch
->recv
->tail
;
185 *ptr
= (void *) (ch
->recv_data
+ tail
);
190 return ch
->fifo_size
- tail
;
193 /* advance the fifo read pointer after data from ch_read_buffer is consumed */
194 static void ch_read_done(struct smd_channel
*ch
, unsigned count
)
196 BUG_ON(count
> smd_stream_read_avail(ch
));
197 ch
->recv
->tail
= (ch
->recv
->tail
+ count
) & ch
->fifo_mask
;
201 /* basic read interface to ch_read_{buffer,done} used
202 * by smd_*_read() and update_packet_state()
203 * will read-and-discard if the _data pointer is null
205 static int ch_read(struct smd_channel
*ch
, void *_data
, int len
)
209 unsigned char *data
= _data
;
213 n
= ch_read_buffer(ch
, &ptr
);
220 memcpy(data
, ptr
, n
);
227 return orig_len
- len
;
230 static void update_stream_state(struct smd_channel
*ch
)
232 /* streams have no special state requiring updating */
235 static void update_packet_state(struct smd_channel
*ch
)
240 /* can't do anything if we're in the middle of a packet */
241 if (ch
->current_packet
!= 0)
244 /* don't bother unless we can get the full header */
245 if (smd_stream_read_avail(ch
) < SMD_HEADER_SIZE
)
248 r
= ch_read(ch
, hdr
, SMD_HEADER_SIZE
);
249 BUG_ON(r
!= SMD_HEADER_SIZE
);
251 ch
->current_packet
= hdr
[0];
254 /* provide a pointer and length to next free space in the fifo */
255 static unsigned ch_write_buffer(struct smd_channel
*ch
, void **ptr
)
257 unsigned head
= ch
->send
->head
;
258 unsigned tail
= ch
->send
->tail
;
259 *ptr
= (void *) (ch
->send_data
+ head
);
262 return tail
- head
- 1;
265 return ch
->fifo_size
- head
- 1;
267 return ch
->fifo_size
- head
;
271 /* advace the fifo write pointer after freespace
272 * from ch_write_buffer is filled
274 static void ch_write_done(struct smd_channel
*ch
, unsigned count
)
276 BUG_ON(count
> smd_stream_write_avail(ch
));
277 ch
->send
->head
= (ch
->send
->head
+ count
) & ch
->fifo_mask
;
281 static void ch_set_state(struct smd_channel
*ch
, unsigned n
)
283 if (n
== SMD_SS_OPENED
) {
293 ch
->send
->fSTATE
= 1;
294 ch
->notify_other_cpu();
297 static void do_smd_probe(void)
299 struct smem_shared
*shared
= (void *) MSM_SHARED_RAM_BASE
;
300 if (shared
->heap_info
.free_offset
!= last_heap_free
) {
301 last_heap_free
= shared
->heap_info
.free_offset
;
302 schedule_work(&probe_work
);
306 static void smd_state_change(struct smd_channel
*ch
,
307 unsigned last
, unsigned next
)
309 ch
->last_state
= next
;
311 pr_debug("ch %d %d -> %d\n", ch
->n
, last
, next
);
317 if (ch
->send
->state
!= SMD_SS_OPENED
)
318 ch_set_state(ch
, SMD_SS_OPENED
);
319 ch
->notify(ch
->priv
, SMD_EVENT_OPEN
);
321 case SMD_SS_FLUSHING
:
323 /* we should force them to close? */
325 ch
->notify(ch
->priv
, SMD_EVENT_CLOSE
);
329 static void handle_smd_irq(struct list_head
*list
, void (*notify
)(void))
332 struct smd_channel
*ch
;
337 spin_lock_irqsave(&smd_lock
, flags
);
338 list_for_each_entry(ch
, list
, ch_list
) {
340 if (ch_is_open(ch
)) {
341 if (ch
->recv
->fHEAD
) {
346 if (ch
->recv
->fTAIL
) {
351 if (ch
->recv
->fSTATE
) {
352 ch
->recv
->fSTATE
= 0;
357 tmp
= ch
->recv
->state
;
358 if (tmp
!= ch
->last_state
)
359 smd_state_change(ch
, ch
->last_state
, tmp
);
361 ch
->update_state(ch
);
362 ch
->notify(ch
->priv
, SMD_EVENT_DATA
);
367 spin_unlock_irqrestore(&smd_lock
, flags
);
371 static irqreturn_t
smd_modem_irq_handler(int irq
, void *data
)
373 handle_smd_irq(&smd_ch_list_modem
, notify_modem_smd
);
377 #if defined(CONFIG_QDSP6)
378 static irqreturn_t
smd_dsp_irq_handler(int irq
, void *data
)
380 handle_smd_irq(&smd_ch_list_dsp
, notify_dsp_smd
);
385 static void smd_fake_irq_handler(unsigned long arg
)
387 handle_smd_irq(&smd_ch_list_modem
, notify_modem_smd
);
388 handle_smd_irq(&smd_ch_list_dsp
, notify_dsp_smd
);
391 static DECLARE_TASKLET(smd_fake_irq_tasklet
, smd_fake_irq_handler
, 0);
393 static inline int smd_need_int(struct smd_channel
*ch
)
395 if (ch_is_open(ch
)) {
396 if (ch
->recv
->fHEAD
|| ch
->recv
->fTAIL
|| ch
->recv
->fSTATE
)
398 if (ch
->recv
->state
!= ch
->last_state
)
404 void smd_sleep_exit(void)
407 struct smd_channel
*ch
;
410 spin_lock_irqsave(&smd_lock
, flags
);
411 list_for_each_entry(ch
, &smd_ch_list_modem
, ch_list
) {
412 if (smd_need_int(ch
)) {
417 list_for_each_entry(ch
, &smd_ch_list_dsp
, ch_list
) {
418 if (smd_need_int(ch
)) {
423 spin_unlock_irqrestore(&smd_lock
, flags
);
427 if (msm_smd_debug_mask
& MSM_SMD_DEBUG
)
428 pr_info("smd_sleep_exit need interrupt\n");
429 tasklet_schedule(&smd_fake_irq_tasklet
);
434 void smd_kick(smd_channel_t
*ch
)
439 spin_lock_irqsave(&smd_lock
, flags
);
440 ch
->update_state(ch
);
441 tmp
= ch
->recv
->state
;
442 if (tmp
!= ch
->last_state
) {
443 ch
->last_state
= tmp
;
444 if (tmp
== SMD_SS_OPENED
)
445 ch
->notify(ch
->priv
, SMD_EVENT_OPEN
);
447 ch
->notify(ch
->priv
, SMD_EVENT_CLOSE
);
449 ch
->notify(ch
->priv
, SMD_EVENT_DATA
);
450 ch
->notify_other_cpu();
451 spin_unlock_irqrestore(&smd_lock
, flags
);
454 static int smd_is_packet(int chn
, unsigned type
)
456 type
&= SMD_KIND_MASK
;
457 if (type
== SMD_KIND_PACKET
)
459 if (type
== SMD_KIND_STREAM
)
462 /* older AMSS reports SMD_KIND_UNKNOWN always */
463 if ((chn
> 4) || (chn
== 1))
469 static int smd_stream_write(smd_channel_t
*ch
, const void *_data
, int len
)
472 const unsigned char *buf
= _data
;
479 while ((xfer
= ch_write_buffer(ch
, &ptr
)) != 0) {
484 memcpy(ptr
, buf
, xfer
);
485 ch_write_done(ch
, xfer
);
492 ch
->notify_other_cpu();
494 return orig_len
- len
;
497 static int smd_packet_write(smd_channel_t
*ch
, const void *_data
, int len
)
504 if (smd_stream_write_avail(ch
) < (len
+ SMD_HEADER_SIZE
))
508 hdr
[1] = hdr
[2] = hdr
[3] = hdr
[4] = 0;
510 smd_stream_write(ch
, hdr
, sizeof(hdr
));
511 smd_stream_write(ch
, _data
, len
);
516 static int smd_stream_read(smd_channel_t
*ch
, void *data
, int len
)
523 r
= ch_read(ch
, data
, len
);
525 ch
->notify_other_cpu();
530 static int smd_packet_read(smd_channel_t
*ch
, void *data
, int len
)
538 if (len
> ch
->current_packet
)
539 len
= ch
->current_packet
;
541 r
= ch_read(ch
, data
, len
);
543 ch
->notify_other_cpu();
545 spin_lock_irqsave(&smd_lock
, flags
);
546 ch
->current_packet
-= r
;
547 update_packet_state(ch
);
548 spin_unlock_irqrestore(&smd_lock
, flags
);
553 static int smd_alloc_channel(const char *name
, uint32_t cid
, uint32_t type
)
555 struct smd_channel
*ch
;
557 ch
= kzalloc(sizeof(struct smd_channel
), GFP_KERNEL
);
559 pr_err("smd_alloc_channel() out of memory\n");
564 if (_smd_alloc_channel(ch
)) {
569 ch
->fifo_mask
= ch
->fifo_size
- 1;
572 if ((type
& SMD_TYPE_MASK
) == SMD_TYPE_APPS_MODEM
)
573 ch
->notify_other_cpu
= notify_modem_smd
;
575 ch
->notify_other_cpu
= notify_dsp_smd
;
577 if (smd_is_packet(cid
, type
)) {
578 ch
->read
= smd_packet_read
;
579 ch
->write
= smd_packet_write
;
580 ch
->read_avail
= smd_packet_read_avail
;
581 ch
->write_avail
= smd_packet_write_avail
;
582 ch
->update_state
= update_packet_state
;
584 ch
->read
= smd_stream_read
;
585 ch
->write
= smd_stream_write
;
586 ch
->read_avail
= smd_stream_read_avail
;
587 ch
->write_avail
= smd_stream_write_avail
;
588 ch
->update_state
= update_stream_state
;
591 if ((type
& 0xff) == 0)
592 memcpy(ch
->name
, "SMD_", 4);
594 memcpy(ch
->name
, "DSP_", 4);
595 memcpy(ch
->name
+ 4, name
, 20);
597 ch
->pdev
.name
= ch
->name
;
600 pr_debug("smd_alloc_channel() cid=%02d size=%05d '%s'\n",
601 ch
->n
, ch
->fifo_size
, ch
->name
);
603 mutex_lock(&smd_creation_mutex
);
604 list_add(&ch
->ch_list
, &smd_ch_closed_list
);
605 mutex_unlock(&smd_creation_mutex
);
607 platform_device_register(&ch
->pdev
);
611 static void smd_channel_probe_worker(struct work_struct
*work
)
613 struct smd_alloc_elm
*shared
;
618 shared
= smem_find(ID_CH_ALLOC_TBL
, sizeof(*shared
) * 64);
620 pr_err("cannot find allocation table\n");
623 for (n
= 0; n
< 64; n
++) {
624 if (smd_ch_allocated
[n
])
626 if (!shared
[n
].ref_count
)
628 if (!shared
[n
].name
[0])
630 ctype
= shared
[n
].ctype
;
631 type
= ctype
& SMD_TYPE_MASK
;
633 /* DAL channels are stream but neither the modem,
634 * nor the DSP correctly indicate this. Fixup manually.
636 if (!memcmp(shared
[n
].name
, "DAL", 3))
637 ctype
= (ctype
& (~SMD_KIND_MASK
)) | SMD_KIND_STREAM
;
639 type
= shared
[n
].ctype
& SMD_TYPE_MASK
;
640 if ((type
== SMD_TYPE_APPS_MODEM
) ||
641 (type
== SMD_TYPE_APPS_DSP
))
642 if (!smd_alloc_channel(shared
[n
].name
, shared
[n
].cid
, ctype
))
643 smd_ch_allocated
[n
] = 1;
647 static void do_nothing_notify(void *priv
, unsigned flags
)
651 struct smd_channel
*smd_get_channel(const char *name
)
653 struct smd_channel
*ch
;
655 mutex_lock(&smd_creation_mutex
);
656 list_for_each_entry(ch
, &smd_ch_closed_list
, ch_list
) {
657 if (!strcmp(name
, ch
->name
)) {
658 list_del(&ch
->ch_list
);
659 mutex_unlock(&smd_creation_mutex
);
663 mutex_unlock(&smd_creation_mutex
);
668 int smd_open(const char *name
, smd_channel_t
**_ch
,
669 void *priv
, void (*notify
)(void *, unsigned))
671 struct smd_channel
*ch
;
674 if (smd_initialized
== 0) {
675 pr_info("smd_open() before smd_init()\n");
679 ch
= smd_get_channel(name
);
684 notify
= do_nothing_notify
;
687 ch
->current_packet
= 0;
688 ch
->last_state
= SMD_SS_CLOSED
;
693 spin_lock_irqsave(&smd_lock
, flags
);
695 if ((ch
->type
& SMD_TYPE_MASK
) == SMD_TYPE_APPS_MODEM
)
696 list_add(&ch
->ch_list
, &smd_ch_list_modem
);
698 list_add(&ch
->ch_list
, &smd_ch_list_dsp
);
700 /* If the remote side is CLOSING, we need to get it to
701 * move to OPENING (which we'll do by moving from CLOSED to
702 * OPENING) and then get it to move from OPENING to
703 * OPENED (by doing the same state change ourselves).
705 * Otherwise, it should be OPENING and we can move directly
706 * to OPENED so that it will follow.
708 if (ch
->recv
->state
== SMD_SS_CLOSING
) {
710 ch_set_state(ch
, SMD_SS_OPENING
);
712 ch_set_state(ch
, SMD_SS_OPENED
);
714 spin_unlock_irqrestore(&smd_lock
, flags
);
720 int smd_close(smd_channel_t
*ch
)
727 spin_lock_irqsave(&smd_lock
, flags
);
728 ch
->notify
= do_nothing_notify
;
729 list_del(&ch
->ch_list
);
730 ch_set_state(ch
, SMD_SS_CLOSED
);
731 spin_unlock_irqrestore(&smd_lock
, flags
);
733 mutex_lock(&smd_creation_mutex
);
734 list_add(&ch
->ch_list
, &smd_ch_closed_list
);
735 mutex_unlock(&smd_creation_mutex
);
740 int smd_read(smd_channel_t
*ch
, void *data
, int len
)
742 return ch
->read(ch
, data
, len
);
745 int smd_write(smd_channel_t
*ch
, const void *data
, int len
)
747 return ch
->write(ch
, data
, len
);
750 int smd_write_atomic(smd_channel_t
*ch
, const void *data
, int len
)
754 spin_lock_irqsave(&smd_lock
, flags
);
755 res
= ch
->write(ch
, data
, len
);
756 spin_unlock_irqrestore(&smd_lock
, flags
);
760 int smd_read_avail(smd_channel_t
*ch
)
762 return ch
->read_avail(ch
);
765 int smd_write_avail(smd_channel_t
*ch
)
767 return ch
->write_avail(ch
);
770 int smd_wait_until_readable(smd_channel_t
*ch
, int bytes
)
775 int smd_wait_until_writable(smd_channel_t
*ch
, int bytes
)
780 int smd_cur_packet_size(smd_channel_t
*ch
)
782 return ch
->current_packet
;
786 /* ------------------------------------------------------------------------- */
788 void *smem_alloc(unsigned id
, unsigned size
)
790 return smem_find(id
, size
);
793 void __iomem
*smem_item(unsigned id
, unsigned *size
)
795 struct smem_shared
*shared
= (void *) MSM_SHARED_RAM_BASE
;
796 struct smem_heap_entry
*toc
= shared
->heap_toc
;
798 if (id
>= SMEM_NUM_ITEMS
)
801 if (toc
[id
].allocated
) {
802 *size
= toc
[id
].size
;
803 return (MSM_SHARED_RAM_BASE
+ toc
[id
].offset
);
811 void *smem_find(unsigned id
, unsigned size_in
)
816 ptr
= smem_item(id
, &size
);
820 size_in
= ALIGN(size_in
, 8);
821 if (size_in
!= size
) {
822 pr_err("smem_find(%d, %d): wrong size %d\n",
830 static irqreturn_t
smsm_irq_handler(int irq
, void *data
)
835 spin_lock_irqsave(&smem_lock
, flags
);
837 apps
= raw_smsm_get_state(SMSM_STATE_APPS
);
838 modm
= raw_smsm_get_state(SMSM_STATE_MODEM
);
840 if (msm_smd_debug_mask
& MSM_SMSM_DEBUG
)
841 pr_info("<SM %08x %08x>\n", apps
, modm
);
842 if (modm
& SMSM_RESET
)
843 handle_modem_crash();
847 spin_unlock_irqrestore(&smem_lock
, flags
);
851 int smsm_change_state(enum smsm_state_item item
,
852 uint32_t clear_mask
, uint32_t set_mask
)
854 void __iomem
*addr
= smd_info
.state
+ item
* 4;
861 spin_lock_irqsave(&smem_lock
, flags
);
863 if (raw_smsm_get_state(SMSM_STATE_MODEM
) & SMSM_RESET
)
864 handle_modem_crash();
866 state
= (readl(addr
) & ~clear_mask
) | set_mask
;
869 if (msm_smd_debug_mask
& MSM_SMSM_DEBUG
)
870 pr_info("smsm_change_state %d %x\n", item
, state
);
873 spin_unlock_irqrestore(&smem_lock
, flags
);
878 uint32_t smsm_get_state(enum smsm_state_item item
)
883 spin_lock_irqsave(&smem_lock
, flags
);
885 rv
= readl(smd_info
.state
+ item
* 4);
887 if (item
== SMSM_STATE_MODEM
&& (rv
& SMSM_RESET
))
888 handle_modem_crash();
890 spin_unlock_irqrestore(&smem_lock
, flags
);
895 #ifdef CONFIG_ARCH_MSM_SCORPION
897 int smsm_set_sleep_duration(uint32_t delay
)
899 struct msm_dem_slave_data
*ptr
;
901 ptr
= smem_find(SMEM_APPS_DEM_SLAVE_DATA
, sizeof(*ptr
));
903 pr_err("smsm_set_sleep_duration <SM NO APPS_DEM_SLAVE_DATA>\n");
906 if (msm_smd_debug_mask
& MSM_SMSM_DEBUG
)
907 pr_info("smsm_set_sleep_duration %d -> %d\n",
908 ptr
->sleep_time
, delay
);
909 ptr
->sleep_time
= delay
;
915 int smsm_set_sleep_duration(uint32_t delay
)
919 ptr
= smem_find(SMEM_SMSM_SLEEP_DELAY
, sizeof(*ptr
));
921 pr_err("smsm_set_sleep_duration <SM NO SLEEP_DELAY>\n");
924 if (msm_smd_debug_mask
& MSM_SMSM_DEBUG
)
925 pr_info("smsm_set_sleep_duration %d -> %d\n",
933 int smd_core_init(void)
937 /* wait for essential items to be initialized */
941 state
= smem_item(SMEM_SMSM_SHARED_STATE
, &size
);
942 if (size
== SMSM_V1_SIZE
|| size
== SMSM_V2_SIZE
) {
943 smd_info
.state
= state
;
950 r
= request_irq(INT_A9_M2A_0
, smd_modem_irq_handler
,
951 IRQF_TRIGGER_RISING
, "smd_dev", 0);
954 r
= enable_irq_wake(INT_A9_M2A_0
);
956 pr_err("smd_core_init: enable_irq_wake failed for A9_M2A_0\n");
958 r
= request_irq(INT_A9_M2A_5
, smsm_irq_handler
,
959 IRQF_TRIGGER_RISING
, "smsm_dev", 0);
961 free_irq(INT_A9_M2A_0
, 0);
964 r
= enable_irq_wake(INT_A9_M2A_5
);
966 pr_err("smd_core_init: enable_irq_wake failed for A9_M2A_5\n");
968 #if defined(CONFIG_QDSP6)
969 r
= request_irq(INT_ADSP_A11
, smd_dsp_irq_handler
,
970 IRQF_TRIGGER_RISING
, "smd_dsp", 0);
972 free_irq(INT_A9_M2A_0
, 0);
973 free_irq(INT_A9_M2A_5
, 0);
978 /* check for any SMD channels that may already exist */
981 /* indicate that we're up and running */
982 smsm_change_state(SMSM_STATE_APPS
,
983 ~0, SMSM_INIT
| SMSM_SMDINIT
| SMSM_RPCINIT
| SMSM_RUN
);
984 #ifdef CONFIG_ARCH_MSM_SCORPION
985 smsm_change_state(SMSM_STATE_APPS_DEM
, ~0, 0);
991 static int msm_smd_probe(struct platform_device
*pdev
)
994 * If we haven't waited for the ARM9 to boot up till now,
995 * then we need to wait here. Otherwise this should just
996 * return immediately.
998 proc_comm_boot_wait();
1000 INIT_WORK(&probe_work
, smd_channel_probe_worker
);
1002 if (smd_core_init()) {
1003 pr_err("smd_core_init() failed\n");
1009 msm_check_for_modem_crash
= check_for_modem_crash
;
1011 msm_init_last_radio_log(THIS_MODULE
);
1013 smd_initialized
= 1;
1018 static struct platform_driver msm_smd_driver
= {
1019 .probe
= msm_smd_probe
,
1021 .name
= MODULE_NAME
,
1022 .owner
= THIS_MODULE
,
1026 static int __init
msm_smd_init(void)
1028 return platform_driver_register(&msm_smd_driver
);
1031 module_init(msm_smd_init
);
1033 MODULE_DESCRIPTION("MSM Shared Memory Core");
1034 MODULE_AUTHOR("Brian Swetland <swetland@google.com>");
1035 MODULE_LICENSE("GPL");