Searched refs:fsm (Results 1 - 78 of 78) sorted by relevance

/linux-4.4.14/drivers/usb/common/
H A Dusb-otg-fsm.c31 #include <linux/usb/otg-fsm.h>
34 static int otg_set_protocol(struct otg_fsm *fsm, int protocol) otg_set_protocol() argument
38 if (fsm->protocol != protocol) { otg_set_protocol()
39 VDBG("Changing role fsm->protocol= %d; new protocol= %d\n", otg_set_protocol()
40 fsm->protocol, protocol); otg_set_protocol()
42 if (fsm->protocol == PROTO_HOST) otg_set_protocol()
43 ret = otg_start_host(fsm, 0); otg_set_protocol()
44 else if (fsm->protocol == PROTO_GADGET) otg_set_protocol()
45 ret = otg_start_gadget(fsm, 0); otg_set_protocol()
51 ret = otg_start_host(fsm, 1); otg_set_protocol()
53 ret = otg_start_gadget(fsm, 1); otg_set_protocol()
57 fsm->protocol = protocol; otg_set_protocol()
67 static void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state) otg_leave_state() argument
71 otg_del_timer(fsm, B_SE0_SRP); otg_leave_state()
72 fsm->b_se0_srp = 0; otg_leave_state()
73 fsm->adp_sns = 0; otg_leave_state()
74 fsm->adp_prb = 0; otg_leave_state()
77 fsm->data_pulse = 0; otg_leave_state()
78 fsm->b_srp_done = 0; otg_leave_state()
83 otg_del_timer(fsm, B_ASE0_BRST); otg_leave_state()
84 fsm->b_ase0_brst_tmout = 0; otg_leave_state()
89 fsm->adp_prb = 0; otg_leave_state()
92 otg_del_timer(fsm, A_WAIT_VRISE); otg_leave_state()
93 fsm->a_wait_vrise_tmout = 0; otg_leave_state()
96 otg_del_timer(fsm, A_WAIT_BCON); otg_leave_state()
97 fsm->a_wait_bcon_tmout = 0; otg_leave_state()
100 otg_del_timer(fsm, A_WAIT_ENUM); otg_leave_state()
103 otg_del_timer(fsm, A_AIDL_BDIS); otg_leave_state()
104 fsm->a_aidl_bdis_tmout = 0; otg_leave_state()
105 fsm->a_suspend_req_inf = 0; otg_leave_state()
108 otg_del_timer(fsm, A_BIDL_ADIS); otg_leave_state()
109 fsm->a_bidl_adis_tmout = 0; otg_leave_state()
112 otg_del_timer(fsm, A_WAIT_VFALL); otg_leave_state()
113 fsm->a_wait_vfall_tmout = 0; otg_leave_state()
114 otg_del_timer(fsm, A_WAIT_VRISE); otg_leave_state()
124 static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state) otg_set_state() argument
127 if (fsm->otg->state == new_state) otg_set_state()
130 otg_leave_state(fsm, fsm->otg->state); otg_set_state()
133 otg_drv_vbus(fsm, 0); otg_set_state()
134 otg_chrg_vbus(fsm, 0); otg_set_state()
135 otg_loc_conn(fsm, 0); otg_set_state()
136 otg_loc_sof(fsm, 0); otg_set_state()
141 otg_start_adp_sns(fsm); otg_set_state()
142 otg_set_protocol(fsm, PROTO_UNDEF); otg_set_state()
143 otg_add_timer(fsm, B_SE0_SRP); otg_set_state()
146 otg_start_pulse(fsm); otg_set_state()
147 otg_loc_sof(fsm, 0); otg_set_state()
148 otg_set_protocol(fsm, PROTO_UNDEF); otg_set_state()
149 otg_add_timer(fsm, B_SRP_FAIL); otg_set_state()
152 otg_chrg_vbus(fsm, 0); otg_set_state()
153 otg_loc_sof(fsm, 0); otg_set_state()
154 otg_set_protocol(fsm, PROTO_GADGET); otg_set_state()
155 otg_loc_conn(fsm, 1); otg_set_state()
158 otg_chrg_vbus(fsm, 0); otg_set_state()
159 otg_loc_conn(fsm, 0); otg_set_state()
160 otg_loc_sof(fsm, 0); otg_set_state()
161 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
162 otg_add_timer(fsm, B_ASE0_BRST); otg_set_state()
163 fsm->a_bus_suspend = 0; otg_set_state()
166 otg_chrg_vbus(fsm, 0); otg_set_state()
167 otg_loc_conn(fsm, 0); otg_set_state()
168 otg_loc_sof(fsm, 1); otg_set_state()
169 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
170 usb_bus_start_enum(fsm->otg->host, otg_set_state()
171 fsm->otg->host->otg_port); otg_set_state()
174 otg_drv_vbus(fsm, 0); otg_set_state()
175 otg_chrg_vbus(fsm, 0); otg_set_state()
176 otg_loc_conn(fsm, 0); otg_set_state()
177 otg_loc_sof(fsm, 0); otg_set_state()
178 otg_start_adp_prb(fsm); otg_set_state()
179 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
182 otg_drv_vbus(fsm, 1); otg_set_state()
183 otg_loc_conn(fsm, 0); otg_set_state()
184 otg_loc_sof(fsm, 0); otg_set_state()
185 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
186 otg_add_timer(fsm, A_WAIT_VRISE); otg_set_state()
189 otg_drv_vbus(fsm, 1); otg_set_state()
190 otg_loc_conn(fsm, 0); otg_set_state()
191 otg_loc_sof(fsm, 0); otg_set_state()
192 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
193 otg_add_timer(fsm, A_WAIT_BCON); otg_set_state()
196 otg_drv_vbus(fsm, 1); otg_set_state()
197 otg_loc_conn(fsm, 0); otg_set_state()
198 otg_loc_sof(fsm, 1); otg_set_state()
199 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
204 if (!fsm->a_bus_req || fsm->a_suspend_req_inf) otg_set_state()
205 otg_add_timer(fsm, A_WAIT_ENUM); otg_set_state()
208 otg_drv_vbus(fsm, 1); otg_set_state()
209 otg_loc_conn(fsm, 0); otg_set_state()
210 otg_loc_sof(fsm, 0); otg_set_state()
211 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
212 otg_add_timer(fsm, A_AIDL_BDIS); otg_set_state()
216 otg_loc_sof(fsm, 0); otg_set_state()
217 otg_set_protocol(fsm, PROTO_GADGET); otg_set_state()
218 otg_drv_vbus(fsm, 1); otg_set_state()
219 otg_loc_conn(fsm, 1); otg_set_state()
220 otg_add_timer(fsm, A_BIDL_ADIS); otg_set_state()
223 otg_drv_vbus(fsm, 0); otg_set_state()
224 otg_loc_conn(fsm, 0); otg_set_state()
225 otg_loc_sof(fsm, 0); otg_set_state()
226 otg_set_protocol(fsm, PROTO_HOST); otg_set_state()
227 otg_add_timer(fsm, A_WAIT_VFALL); otg_set_state()
230 otg_drv_vbus(fsm, 0); otg_set_state()
231 otg_loc_conn(fsm, 0); otg_set_state()
232 otg_loc_sof(fsm, 0); otg_set_state()
233 otg_set_protocol(fsm, PROTO_UNDEF); otg_set_state()
239 fsm->otg->state = new_state; otg_set_state()
244 int otg_statemachine(struct otg_fsm *fsm) otg_statemachine() argument
248 mutex_lock(&fsm->lock); otg_statemachine()
250 state = fsm->otg->state; otg_statemachine()
256 VDBG("fsm->id = %d\n", fsm->id); otg_statemachine()
257 if (fsm->id) otg_statemachine()
258 otg_set_state(fsm, OTG_STATE_B_IDLE); otg_statemachine()
260 otg_set_state(fsm, OTG_STATE_A_IDLE); otg_statemachine()
263 if (!fsm->id) otg_statemachine()
264 otg_set_state(fsm, OTG_STATE_A_IDLE); otg_statemachine()
265 else if (fsm->b_sess_vld && fsm->otg->gadget) otg_statemachine()
266 otg_set_state(fsm, OTG_STATE_B_PERIPHERAL); otg_statemachine()
267 else if ((fsm->b_bus_req || fsm->adp_change || fsm->power_up) && otg_statemachine()
268 fsm->b_ssend_srp && fsm->b_se0_srp) otg_statemachine()
269 otg_set_state(fsm, OTG_STATE_B_SRP_INIT); otg_statemachine()
272 if (!fsm->id || fsm->b_srp_done) otg_statemachine()
273 otg_set_state(fsm, OTG_STATE_B_IDLE); otg_statemachine()
276 if (!fsm->id || !fsm->b_sess_vld) otg_statemachine()
277 otg_set_state(fsm, OTG_STATE_B_IDLE); otg_statemachine()
278 else if (fsm->b_bus_req && fsm->otg-> otg_statemachine()
279 gadget->b_hnp_enable && fsm->a_bus_suspend) otg_statemachine()
280 otg_set_state(fsm, OTG_STATE_B_WAIT_ACON); otg_statemachine()
283 if (fsm->a_conn) otg_statemachine()
284 otg_set_state(fsm, OTG_STATE_B_HOST); otg_statemachine()
285 else if (!fsm->id || !fsm->b_sess_vld) otg_statemachine()
286 otg_set_state(fsm, OTG_STATE_B_IDLE); otg_statemachine()
287 else if (fsm->a_bus_resume || fsm->b_ase0_brst_tmout) { otg_statemachine()
288 fsm->b_ase0_brst_tmout = 0; otg_statemachine()
289 otg_set_state(fsm, OTG_STATE_B_PERIPHERAL); otg_statemachine()
293 if (!fsm->id || !fsm->b_sess_vld) otg_statemachine()
294 otg_set_state(fsm, OTG_STATE_B_IDLE); otg_statemachine()
295 else if (!fsm->b_bus_req || !fsm->a_conn || fsm->test_device) otg_statemachine()
296 otg_set_state(fsm, OTG_STATE_B_PERIPHERAL); otg_statemachine()
299 if (fsm->id) otg_statemachine()
300 otg_set_state(fsm, OTG_STATE_B_IDLE); otg_statemachine()
301 else if (!fsm->a_bus_drop && (fsm->a_bus_req || otg_statemachine()
302 fsm->a_srp_det || fsm->adp_change || fsm->power_up)) otg_statemachine()
303 otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE); otg_statemachine()
306 if (fsm->a_vbus_vld) otg_statemachine()
307 otg_set_state(fsm, OTG_STATE_A_WAIT_BCON); otg_statemachine()
308 else if (fsm->id || fsm->a_bus_drop || otg_statemachine()
309 fsm->a_wait_vrise_tmout) otg_statemachine()
310 otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL); otg_statemachine()
313 if (!fsm->a_vbus_vld) otg_statemachine()
314 otg_set_state(fsm, OTG_STATE_A_VBUS_ERR); otg_statemachine()
315 else if (fsm->b_conn) otg_statemachine()
316 otg_set_state(fsm, OTG_STATE_A_HOST); otg_statemachine()
317 else if (fsm->id || fsm->a_bus_drop || fsm->a_wait_bcon_tmout) otg_statemachine()
318 otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL); otg_statemachine()
321 if (fsm->id || fsm->a_bus_drop) otg_statemachine()
322 otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL); otg_statemachine()
323 else if ((!fsm->a_bus_req || fsm->a_suspend_req_inf) && otg_statemachine()
324 fsm->otg->host->b_hnp_enable) otg_statemachine()
325 otg_set_state(fsm, OTG_STATE_A_SUSPEND); otg_statemachine()
326 else if (!fsm->b_conn) otg_statemachine()
327 otg_set_state(fsm, OTG_STATE_A_WAIT_BCON); otg_statemachine()
328 else if (!fsm->a_vbus_vld) otg_statemachine()
329 otg_set_state(fsm, OTG_STATE_A_VBUS_ERR); otg_statemachine()
332 if (!fsm->b_conn && fsm->otg->host->b_hnp_enable) otg_statemachine()
333 otg_set_state(fsm, OTG_STATE_A_PERIPHERAL); otg_statemachine()
334 else if (!fsm->b_conn && !fsm->otg->host->b_hnp_enable) otg_statemachine()
335 otg_set_state(fsm, OTG_STATE_A_WAIT_BCON); otg_statemachine()
336 else if (fsm->a_bus_req || fsm->b_bus_resume) otg_statemachine()
337 otg_set_state(fsm, OTG_STATE_A_HOST); otg_statemachine()
338 else if (fsm->id || fsm->a_bus_drop || fsm->a_aidl_bdis_tmout) otg_statemachine()
339 otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL); otg_statemachine()
340 else if (!fsm->a_vbus_vld) otg_statemachine()
341 otg_set_state(fsm, OTG_STATE_A_VBUS_ERR); otg_statemachine()
344 if (fsm->id || fsm->a_bus_drop) otg_statemachine()
345 otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL); otg_statemachine()
346 else if (fsm->a_bidl_adis_tmout || fsm->b_bus_suspend) otg_statemachine()
347 otg_set_state(fsm, OTG_STATE_A_WAIT_BCON); otg_statemachine()
348 else if (!fsm->a_vbus_vld) otg_statemachine()
349 otg_set_state(fsm, OTG_STATE_A_VBUS_ERR); otg_statemachine()
352 if (fsm->a_wait_vfall_tmout) otg_statemachine()
353 otg_set_state(fsm, OTG_STATE_A_IDLE); otg_statemachine()
356 if (fsm->id || fsm->a_bus_drop || fsm->a_clr_err) otg_statemachine()
357 otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL); otg_statemachine()
362 mutex_unlock(&fsm->lock); otg_statemachine()
/linux-4.4.14/include/linux/usb/
H A Dotg-fsm.h125 void (*chrg_vbus)(struct otg_fsm *fsm, int on);
126 void (*drv_vbus)(struct otg_fsm *fsm, int on);
127 void (*loc_conn)(struct otg_fsm *fsm, int on);
128 void (*loc_sof)(struct otg_fsm *fsm, int on);
129 void (*start_pulse)(struct otg_fsm *fsm);
130 void (*start_adp_prb)(struct otg_fsm *fsm);
131 void (*start_adp_sns)(struct otg_fsm *fsm);
132 void (*add_timer)(struct otg_fsm *fsm, enum otg_fsm_timer timer);
133 void (*del_timer)(struct otg_fsm *fsm, enum otg_fsm_timer timer);
134 int (*start_host)(struct otg_fsm *fsm, int on);
135 int (*start_gadget)(struct otg_fsm *fsm, int on);
139 static inline int otg_chrg_vbus(struct otg_fsm *fsm, int on) otg_chrg_vbus() argument
141 if (!fsm->ops->chrg_vbus) otg_chrg_vbus()
143 fsm->ops->chrg_vbus(fsm, on); otg_chrg_vbus()
147 static inline int otg_drv_vbus(struct otg_fsm *fsm, int on) otg_drv_vbus() argument
149 if (!fsm->ops->drv_vbus) otg_drv_vbus()
151 if (fsm->drv_vbus != on) { otg_drv_vbus()
152 fsm->drv_vbus = on; otg_drv_vbus()
153 fsm->ops->drv_vbus(fsm, on); otg_drv_vbus()
158 static inline int otg_loc_conn(struct otg_fsm *fsm, int on) otg_loc_conn() argument
160 if (!fsm->ops->loc_conn) otg_loc_conn()
162 if (fsm->loc_conn != on) { otg_loc_conn()
163 fsm->loc_conn = on; otg_loc_conn()
164 fsm->ops->loc_conn(fsm, on); otg_loc_conn()
169 static inline int otg_loc_sof(struct otg_fsm *fsm, int on) otg_loc_sof() argument
171 if (!fsm->ops->loc_sof) otg_loc_sof()
173 if (fsm->loc_sof != on) { otg_loc_sof()
174 fsm->loc_sof = on; otg_loc_sof()
175 fsm->ops->loc_sof(fsm, on); otg_loc_sof()
180 static inline int otg_start_pulse(struct otg_fsm *fsm) otg_start_pulse() argument
182 if (!fsm->ops->start_pulse) otg_start_pulse()
184 if (!fsm->data_pulse) { otg_start_pulse()
185 fsm->data_pulse = 1; otg_start_pulse()
186 fsm->ops->start_pulse(fsm); otg_start_pulse()
191 static inline int otg_start_adp_prb(struct otg_fsm *fsm) otg_start_adp_prb() argument
193 if (!fsm->ops->start_adp_prb) otg_start_adp_prb()
195 if (!fsm->adp_prb) { otg_start_adp_prb()
196 fsm->adp_sns = 0; otg_start_adp_prb()
197 fsm->adp_prb = 1; otg_start_adp_prb()
198 fsm->ops->start_adp_prb(fsm); otg_start_adp_prb()
203 static inline int otg_start_adp_sns(struct otg_fsm *fsm) otg_start_adp_sns() argument
205 if (!fsm->ops->start_adp_sns) otg_start_adp_sns()
207 if (!fsm->adp_sns) { otg_start_adp_sns()
208 fsm->adp_sns = 1; otg_start_adp_sns()
209 fsm->ops->start_adp_sns(fsm); otg_start_adp_sns()
214 static inline int otg_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer timer) otg_add_timer() argument
216 if (!fsm->ops->add_timer) otg_add_timer()
218 fsm->ops->add_timer(fsm, timer); otg_add_timer()
222 static inline int otg_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer timer) otg_del_timer() argument
224 if (!fsm->ops->del_timer) otg_del_timer()
226 fsm->ops->del_timer(fsm, timer); otg_del_timer()
230 static inline int otg_start_host(struct otg_fsm *fsm, int on) otg_start_host() argument
232 if (!fsm->ops->start_host) otg_start_host()
234 return fsm->ops->start_host(fsm, on); otg_start_host()
237 static inline int otg_start_gadget(struct otg_fsm *fsm, int on) otg_start_gadget() argument
239 if (!fsm->ops->start_gadget) otg_start_gadget()
241 return fsm->ops->start_gadget(fsm, on); otg_start_gadget()
244 int otg_statemachine(struct otg_fsm *fsm);
/linux-4.4.14/drivers/usb/chipidea/
H A Dotg_fsm.c14 * This file mainly handles OTG fsm, it includes OTG fsm operations
43 t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_req); get_a_bus_req()
59 mutex_lock(&ci->fsm.lock); set_a_bus_req()
61 ci->fsm.a_bus_req = 0; set_a_bus_req()
64 if (ci->fsm.a_bus_drop) { set_a_bus_req()
65 mutex_unlock(&ci->fsm.lock); set_a_bus_req()
68 ci->fsm.a_bus_req = 1; set_a_bus_req()
72 mutex_unlock(&ci->fsm.lock); set_a_bus_req()
87 t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_drop); get_a_bus_drop()
103 mutex_lock(&ci->fsm.lock); set_a_bus_drop()
105 ci->fsm.a_bus_drop = 0; set_a_bus_drop()
107 ci->fsm.a_bus_drop = 1; set_a_bus_drop()
108 ci->fsm.a_bus_req = 0; set_a_bus_drop()
112 mutex_unlock(&ci->fsm.lock); set_a_bus_drop()
128 t = scnprintf(next, size, "%d\n", ci->fsm.b_bus_req); get_b_bus_req()
144 mutex_lock(&ci->fsm.lock); set_b_bus_req()
146 ci->fsm.b_bus_req = 0; set_b_bus_req()
148 ci->fsm.b_bus_req = 1; set_b_bus_req()
151 mutex_unlock(&ci->fsm.lock); set_b_bus_req()
166 mutex_lock(&ci->fsm.lock); set_a_clr_err()
168 ci->fsm.a_clr_err = 1; set_a_clr_err()
171 mutex_unlock(&ci->fsm.lock); set_a_clr_err()
192 * by enum otg_fsm_timer in include/linux/usb/otg-fsm.h
278 ci->fsm.a_wait_vrise_tmout = 1; a_wait_vrise_tmout()
284 ci->fsm.a_wait_vfall_tmout = 1; a_wait_vfall_tmout()
290 ci->fsm.a_wait_bcon_tmout = 1; a_wait_bcon_tmout()
296 ci->fsm.a_aidl_bdis_tmout = 1; a_aidl_bdis_tmout()
302 ci->fsm.b_ase0_brst_tmout = 1; b_ase0_brst_tmout()
308 ci->fsm.a_bidl_adis_tmout = 1; a_bidl_adis_tmout()
314 ci->fsm.b_se0_srp = 1; b_se0_srp_tmout()
320 ci->fsm.b_srp_done = 1; b_srp_fail_tmout()
326 ci->fsm.b_srp_done = 1; b_data_pls_tmout()
327 ci->fsm.b_bus_req = 0; b_data_pls_tmout()
328 if (ci->fsm.power_up) b_data_pls_tmout()
329 ci->fsm.power_up = 0; b_data_pls_tmout()
337 ci->fsm.b_ssend_srp = 1; b_ssend_srp_tmout()
339 if (ci->fsm.otg->state == OTG_STATE_B_IDLE) b_ssend_srp_tmout()
347 * by enum otg_fsm_timer in include/linux/usb/otg-fsm.h
419 static void ci_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t) ci_otg_fsm_add_timer() argument
421 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_fsm_add_timer()
428 static void ci_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t) ci_otg_fsm_del_timer() argument
430 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_fsm_del_timer()
441 static void ci_otg_drv_vbus(struct otg_fsm *fsm, int on) ci_otg_drv_vbus() argument
444 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_drv_vbus()
462 fsm->a_srp_det = 0; ci_otg_drv_vbus()
463 fsm->power_up = 0; ci_otg_drv_vbus()
468 fsm->a_bus_drop = 1; ci_otg_drv_vbus()
469 fsm->a_bus_req = 0; ci_otg_drv_vbus()
476 static void ci_otg_loc_conn(struct otg_fsm *fsm, int on) ci_otg_loc_conn() argument
478 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_loc_conn()
492 static void ci_otg_loc_sof(struct otg_fsm *fsm, int on) ci_otg_loc_sof() argument
494 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_loc_sof()
508 static void ci_otg_start_pulse(struct otg_fsm *fsm) ci_otg_start_pulse() argument
510 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_start_pulse()
519 static int ci_otg_start_host(struct otg_fsm *fsm, int on) ci_otg_start_host() argument
521 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_start_host()
533 static int ci_otg_start_gadget(struct otg_fsm *fsm, int on) ci_otg_start_gadget() argument
535 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); ci_otg_start_gadget()
559 * Don't do fsm transition for B device ci_otg_fsm_work()
562 if (ci->fsm.id && !(ci->driver) && ci_otg_fsm_work()
563 ci->fsm.otg->state < OTG_STATE_A_IDLE) ci_otg_fsm_work()
567 if (otg_statemachine(&ci->fsm)) { ci_otg_fsm_work()
568 if (ci->fsm.otg->state == OTG_STATE_A_IDLE) { ci_otg_fsm_work()
577 if ((ci->fsm.id) || (ci->id_event) || ci_otg_fsm_work()
578 (ci->fsm.power_up)) { ci_otg_fsm_work()
589 } else if (ci->fsm.otg->state == OTG_STATE_B_IDLE) { ci_otg_fsm_work()
590 if (ci->fsm.b_sess_vld) { ci_otg_fsm_work()
591 ci->fsm.power_up = 0; ci_otg_fsm_work()
598 } else if (ci->fsm.otg->state == OTG_STATE_A_HOST) { ci_otg_fsm_work()
609 * Update fsm variables in each state if catching expected interrupts,
610 * called by otg fsm isr.
615 struct otg_fsm *fsm = &ci->fsm; ci_otg_fsm_event() local
621 switch (ci->fsm.otg->state) { ci_otg_fsm_event()
624 fsm->b_conn = 1; ci_otg_fsm_event()
625 fsm->a_bus_req = 1; ci_otg_fsm_event()
631 fsm->b_sess_vld = 1; ci_otg_fsm_event()
637 fsm->a_bus_suspend = 1; ci_otg_fsm_event()
640 if (fsm->a_bus_suspend == 1) ci_otg_fsm_event()
641 fsm->a_bus_suspend = 0; ci_otg_fsm_event()
646 fsm->a_conn = 0; ci_otg_fsm_event()
647 fsm->b_bus_req = 0; ci_otg_fsm_event()
653 fsm->b_bus_suspend = 1; ci_otg_fsm_event()
666 if (fsm->b_bus_suspend == 1) { ci_otg_fsm_event()
668 fsm->b_bus_suspend = 0; ci_otg_fsm_event()
674 fsm->b_conn = 0; ci_otg_fsm_event()
686 fsm->b_conn = 0; ci_otg_fsm_event()
692 fsm->a_conn = 1; ci_otg_fsm_event()
702 * ci_otg_irq - otg fsm related irq handling
703 * and also update otg fsm variable by monitoring usb host and udc
711 struct otg_fsm *fsm = &ci->fsm; ci_otg_fsm_irq() local
715 fsm->id = (otgsc & OTGSC_ID) ? 1 : 0; ci_otg_fsm_irq()
720 fsm->a_srp_det = 1; ci_otg_fsm_irq()
721 fsm->a_bus_drop = 0; ci_otg_fsm_irq()
724 if (fsm->id == 0) { ci_otg_fsm_irq()
725 fsm->a_bus_drop = 0; ci_otg_fsm_irq()
726 fsm->a_bus_req = 1; ci_otg_fsm_irq()
732 fsm->b_sess_vld = 1; ci_otg_fsm_irq()
735 fsm->b_ssend_srp = 0; ci_otg_fsm_irq()
737 fsm->b_sess_vld = 0; ci_otg_fsm_irq()
738 if (fsm->id) ci_otg_fsm_irq()
744 fsm->a_vbus_vld = 1; ci_otg_fsm_irq()
746 fsm->a_vbus_vld = 0; ci_otg_fsm_irq()
747 fsm->b_conn = 0; ci_otg_fsm_irq()
774 ci->fsm.otg = &ci->otg; ci_hdrc_otg_fsm_init()
775 ci->fsm.power_up = 1; ci_hdrc_otg_fsm_init()
776 ci->fsm.id = hw_read_otgsc(ci, OTGSC_ID) ? 1 : 0; ci_hdrc_otg_fsm_init()
777 ci->fsm.otg->state = OTG_STATE_UNDEFINED; ci_hdrc_otg_fsm_init()
778 ci->fsm.ops = &ci_otg_ops; ci_hdrc_otg_fsm_init()
780 mutex_init(&ci->fsm.lock); ci_hdrc_otg_fsm_init()
800 if (ci->fsm.id) { ci_hdrc_otg_fsm_init()
801 ci->fsm.b_ssend_srp = ci_hdrc_otg_fsm_init()
803 ci->fsm.b_sess_vld = ci_hdrc_otg_fsm_init()
H A Ddebug.c12 #include <linux/usb/otg-fsm.h>
223 struct otg_fsm *fsm; ci_otg_show() local
228 fsm = &ci->fsm; ci_otg_show()
235 seq_printf(s, "a_bus_drop: %d\n", fsm->a_bus_drop); ci_otg_show()
237 seq_printf(s, "a_bus_req: %d\n", fsm->a_bus_req); ci_otg_show()
239 seq_printf(s, "a_srp_det: %d\n", fsm->a_srp_det); ci_otg_show()
241 seq_printf(s, "a_vbus_vld: %d\n", fsm->a_vbus_vld); ci_otg_show()
243 seq_printf(s, "b_conn: %d\n", fsm->b_conn); ci_otg_show()
245 seq_printf(s, "adp_change: %d\n", fsm->adp_change); ci_otg_show()
247 seq_printf(s, "power_up: %d\n", fsm->power_up); ci_otg_show()
249 seq_printf(s, "a_bus_resume: %d\n", fsm->a_bus_resume); ci_otg_show()
251 seq_printf(s, "a_bus_suspend: %d\n", fsm->a_bus_suspend); ci_otg_show()
253 seq_printf(s, "a_conn: %d\n", fsm->a_conn); ci_otg_show()
255 seq_printf(s, "b_bus_req: %d\n", fsm->b_bus_req); ci_otg_show()
257 seq_printf(s, "b_bus_suspend: %d\n", fsm->b_bus_suspend); ci_otg_show()
259 seq_printf(s, "b_se0_srp: %d\n", fsm->b_se0_srp); ci_otg_show()
261 seq_printf(s, "b_ssend_srp: %d\n", fsm->b_ssend_srp); ci_otg_show()
263 seq_printf(s, "b_sess_vld: %d\n", fsm->b_sess_vld); ci_otg_show()
265 seq_printf(s, "b_srp_done: %d\n", fsm->b_srp_done); ci_otg_show()
267 seq_printf(s, "drv_vbus: %d\n", fsm->drv_vbus); ci_otg_show()
269 seq_printf(s, "loc_conn: %d\n", fsm->loc_conn); ci_otg_show()
271 seq_printf(s, "loc_sof: %d\n", fsm->loc_sof); ci_otg_show()
273 seq_printf(s, "adp_prb: %d\n", fsm->adp_prb); ci_otg_show()
275 seq_printf(s, "id: %d\n", fsm->id); ci_otg_show()
277 seq_printf(s, "protocol: %d\n", fsm->protocol); ci_otg_show()
H A Dci.h20 #include <linux/usb/otg-fsm.h>
166 * @fsm: otg finite state machine
167 * @otg_fsm_hrtimer: hrtimer for otg fsm timers
168 * @hr_timeouts: time out list for active otg fsm timers
212 struct otg_fsm fsm; member in struct:ci_hdrc
404 * is in otg fsm mode.
H A Dotg_fsm.h14 #include <linux/usb/otg-fsm.h>
H A Dotg.c14 * This file mainly handles otgsc register, OTG fsm operations for HNP and SRP
H A Dudc.c23 #include <linux/usb/otg-fsm.h>
1588 /* Data+ pullup controlled by OTG state machine in OTG fsm mode */ ci_udc_pullup()
1730 /* Start otg fsm for B-device */ ci_udc_start()
1731 if (ci_otg_is_fsm_mode(ci) && ci->fsm.id) { ci_udc_start()
1759 mutex_lock(&ci->fsm.lock); ci_udc_stop_for_otg_fsm()
1760 if (ci->fsm.otg->state == OTG_STATE_A_PERIPHERAL) { ci_udc_stop_for_otg_fsm()
1761 ci->fsm.a_bidl_adis_tmout = 1; ci_udc_stop_for_otg_fsm()
1763 } else if (ci->fsm.otg->state == OTG_STATE_B_PERIPHERAL) { ci_udc_stop_for_otg_fsm()
1764 ci->fsm.protocol = PROTO_UNDEF; ci_udc_stop_for_otg_fsm()
1765 ci->fsm.otg->state = OTG_STATE_UNDEFINED; ci_udc_stop_for_otg_fsm()
1767 mutex_unlock(&ci->fsm.lock); ci_udc_stop_for_otg_fsm()
H A Dcore.c1100 if ((ci->fsm.otg->state == OTG_STATE_A_IDLE) && ci_otg_fsm_suspend_for_srp()
1112 if ((ci->fsm.otg->state == OTG_STATE_A_IDLE) && ci_otg_fsm_wakeup_by_srp()
1113 (ci->fsm.a_bus_drop == 1) && (ci->fsm.a_bus_req == 0)) { ci_otg_fsm_wakeup_by_srp()
1115 ci->fsm.a_srp_det = 1; ci_otg_fsm_wakeup_by_srp()
1116 ci->fsm.a_bus_drop = 0; ci_otg_fsm_wakeup_by_srp()
1118 ci->fsm.id = 1; ci_otg_fsm_wakeup_by_srp()
/linux-4.4.14/drivers/isdn/hisax/
H A Dfsm.c1 /* $Id: fsm.c,v 1.14.6.4 2001/09/23 22:24:47 kai Exp $
25 FsmNew(struct Fsm *fsm, struct FsmNode *fnlist, int fncount) FsmNew() argument
29 fsm->jumpmatrix = FsmNew()
30 kzalloc(sizeof(FSMFNPTR) * fsm->state_count * fsm->event_count, GFP_KERNEL); FsmNew()
31 if (!fsm->jumpmatrix) FsmNew()
35 if ((fnlist[i].state >= fsm->state_count) || (fnlist[i].event >= fsm->event_count)) { FsmNew()
37 i, (long)fnlist[i].state, (long)fsm->state_count, FsmNew()
38 (long)fnlist[i].event, (long)fsm->event_count); FsmNew()
40 fsm->jumpmatrix[fsm->state_count * fnlist[i].event + FsmNew()
46 FsmFree(struct Fsm *fsm) FsmFree() argument
48 kfree((void *) fsm->jumpmatrix); FsmFree()
56 if ((fi->state >= fi->fsm->state_count) || (event >= fi->fsm->event_count)) { FsmEvent()
58 (long)fi->state, (long)fi->fsm->state_count, event, (long)fi->fsm->event_count); FsmEvent()
61 r = fi->fsm->jumpmatrix[fi->fsm->state_count * event + fi->state]; FsmEvent()
65 fi->fsm->strState[fi->state], FsmEvent()
66 fi->fsm->strEvent[event]); FsmEvent()
72 fi->fsm->strState[fi->state], FsmEvent()
73 fi->fsm->strEvent[event]); FsmEvent()
84 fi->fsm->strState[newstate]); FsmChangeState()
H A Dst5481_d.c289 FsmEvent(&adapter->d_out.fsm, EV_DOUT_STOPPED, NULL); dout_stop_event()
304 if (d_out->fsm.state != ST_DOUT_NORMAL) usb_d_out()
330 FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN); usb_d_out()
372 FsmEvent(&adapter->d_out.fsm, EV_DOUT_RESETED, NULL); fifo_reseted()
403 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COMPLETE, (void *) buf_nr); usb_d_out_complete()
408 static void dout_start_xmit(struct FsmInst *fsm, int event, void *arg) dout_start_xmit() argument
411 struct st5481_adapter *adapter = fsm->userdata; dout_start_xmit()
437 FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_INIT); dout_start_xmit()
439 FsmChangeState(&d_out->fsm, ST_DOUT_LONG_INIT); dout_start_xmit()
462 static void dout_short_fifo(struct FsmInst *fsm, int event, void *arg) dout_short_fifo() argument
464 struct st5481_adapter *adapter = fsm->userdata; dout_short_fifo()
467 FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_WAIT_DEN); dout_short_fifo()
471 static void dout_end_short_frame(struct FsmInst *fsm, int event, void *arg) dout_end_short_frame() argument
473 struct st5481_adapter *adapter = fsm->userdata; dout_end_short_frame()
476 FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN); dout_end_short_frame()
479 static void dout_long_enable_fifo(struct FsmInst *fsm, int event, void *arg) dout_long_enable_fifo() argument
481 struct st5481_adapter *adapter = fsm->userdata; dout_long_enable_fifo()
485 FsmChangeState(&d_out->fsm, ST_DOUT_LONG_WAIT_DEN); dout_long_enable_fifo()
488 static void dout_long_den(struct FsmInst *fsm, int event, void *arg) dout_long_den() argument
490 struct st5481_adapter *adapter = fsm->userdata; dout_long_den()
493 FsmChangeState(&d_out->fsm, ST_DOUT_NORMAL); dout_long_den()
498 static void dout_reset(struct FsmInst *fsm, int event, void *arg) dout_reset() argument
500 struct st5481_adapter *adapter = fsm->userdata; dout_reset()
503 FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_RESET); dout_reset()
507 static void dout_stop(struct FsmInst *fsm, int event, void *arg) dout_stop() argument
509 struct st5481_adapter *adapter = fsm->userdata; dout_stop()
512 FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_STOP); dout_stop()
516 static void dout_underrun(struct FsmInst *fsm, int event, void *arg) dout_underrun() argument
518 struct st5481_adapter *adapter = fsm->userdata; dout_underrun()
522 FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_NOT_BUSY); dout_underrun()
524 dout_stop(fsm, event, arg); dout_underrun()
528 static void dout_check_busy(struct FsmInst *fsm, int event, void *arg) dout_check_busy() argument
530 struct st5481_adapter *adapter = fsm->userdata; dout_check_busy()
534 dout_stop(fsm, event, arg); dout_check_busy()
537 static void dout_reseted(struct FsmInst *fsm, int event, void *arg) dout_reseted() argument
539 struct st5481_adapter *adapter = fsm->userdata; dout_reseted()
542 FsmChangeState(&d_out->fsm, ST_DOUT_NONE); dout_reseted()
545 FsmEvent(&d_out->fsm, EV_DOUT_START_XMIT, NULL); dout_reseted()
548 static void dout_complete(struct FsmInst *fsm, int event, void *arg) dout_complete() argument
550 struct st5481_adapter *adapter = fsm->userdata; dout_complete()
556 static void dout_ignore(struct FsmInst *fsm, int event, void *arg) dout_ignore() argument
603 FsmEvent(&adapter->d_out.fsm, EV_DOUT_START_XMIT, NULL); st5481_d_l2l1()
624 FsmChangeState(&d_out->fsm, ST_DOUT_NONE); ph_connect()
714 adapter->l1m.fsm = &l1fsm; st5481_setup_d()
721 adapter->d_out.fsm.fsm = &dout_fsm; st5481_setup_d()
722 adapter->d_out.fsm.state = ST_DOUT_NONE; st5481_setup_d()
723 adapter->d_out.fsm.debug = st5481_debug & 0x100; st5481_setup_d()
724 adapter->d_out.fsm.userdata = adapter; st5481_setup_d()
725 adapter->d_out.fsm.printdebug = dout_debug; st5481_setup_d()
H A Dfsm.h1 /* $Id: fsm.h,v 1.3.2.2 2001/09/23 22:24:47 kai Exp $
30 struct Fsm *fsm; member in struct:FsmInst
50 int FsmNew(struct Fsm *fsm, struct FsmNode *fnlist, int fncount);
51 void FsmFree(struct Fsm *fsm);
H A Dhisax_isac.h5 #include "fsm.h"
H A DMakefile25 lmgr.o q931.o callc.o fsm.o
H A Dst5481_usb.c207 FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL); usb_int_complete()
210 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL); usb_int_complete()
214 FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL); usb_int_complete()
H A Disdnl1.c814 st->l1.l1m.fsm->strState[st->l1.l1m.state]); dch_l2l1()
894 st->l1.l1m.fsm = &l1fsm_s; setstack_HiSax()
899 st->l1.l1m.fsm = &l1fsm_u; setstack_HiSax()
922 st->l1.l1m.fsm = &l1fsm_b; setstack_l1_B()
H A Disdnl3.c337 st->l3.l3m.fsm = &l3fsm; setstack_l3dc()
407 st->l3.l3m.fsm = &l3fsm; setstack_l3bc()
H A Dst5481.h230 #include "fsm.h"
342 struct FsmInst fsm; member in struct:st5481_d_out
H A Dhisax.h177 struct Fsm *fsm; member in struct:FsmInst
1276 int FsmNew(struct Fsm *fsm, struct FsmNode *fnlist, int fncount);
1277 void FsmFree(struct Fsm *fsm);
H A Dtei.c411 st->ma.tei_m.fsm = &teifsm; setstack_tei()
H A Dhisax_isac.c760 isac->l1m.fsm = &l1fsm; isac_init()
H A Dcallc.c1101 chanp->fi.fsm = &callcfsm; init_chan()
H A Disdnl2.c1782 st->l2.l2m.fsm = &l2fsm; setstack_isdnl2()
/linux-4.4.14/drivers/mtd/devices/
H A Dst_spi_fsm.c316 static int stfsm_n25q_config(struct stfsm *fsm);
317 static int stfsm_mx25_config(struct stfsm *fsm);
318 static int stfsm_s25fl_config(struct stfsm *fsm);
319 static int stfsm_w25q_config(struct stfsm *fsm);
707 static inline int stfsm_is_idle(struct stfsm *fsm) stfsm_is_idle() argument
709 return readl(fsm->base + SPI_FAST_SEQ_STA) & 0x10; stfsm_is_idle()
712 static inline uint32_t stfsm_fifo_available(struct stfsm *fsm) stfsm_fifo_available() argument
714 return (readl(fsm->base + SPI_FAST_SEQ_STA) >> 5) & 0x7f; stfsm_fifo_available()
717 static inline void stfsm_load_seq(struct stfsm *fsm, stfsm_load_seq() argument
720 void __iomem *dst = fsm->base + SPI_FAST_SEQ_TRANSFER_SIZE; stfsm_load_seq()
724 BUG_ON(!stfsm_is_idle(fsm)); stfsm_load_seq()
733 static void stfsm_wait_seq(struct stfsm *fsm) stfsm_wait_seq() argument
744 if (stfsm_is_idle(fsm)) stfsm_wait_seq()
750 dev_err(fsm->dev, "timeout on sequence completion\n"); stfsm_wait_seq()
753 static void stfsm_read_fifo(struct stfsm *fsm, uint32_t *buf, uint32_t size) stfsm_read_fifo() argument
759 dev_dbg(fsm->dev, "Reading %d bytes from FIFO\n", size); stfsm_read_fifo()
765 avail = stfsm_fifo_available(fsm); stfsm_read_fifo()
773 readsl(fsm->base + SPI_FAST_SEQ_DATA_REG, buf, words); stfsm_read_fifo()
804 static void stfsm_clear_fifo(struct stfsm *fsm) stfsm_clear_fifo() argument
810 words = stfsm_fifo_available(fsm); stfsm_clear_fifo()
813 readl(fsm->base + SPI_FAST_SEQ_DATA_REG); stfsm_clear_fifo()
814 dev_dbg(fsm->dev, "cleared %d words from FIFO\n", words); stfsm_clear_fifo()
823 stfsm_load_seq(fsm, seq); stfsm_clear_fifo()
824 stfsm_wait_seq(fsm); stfsm_clear_fifo()
825 words = stfsm_fifo_available(fsm); stfsm_clear_fifo()
830 dev_err(fsm->dev, "failed to clear bytes from the data FIFO\n"); stfsm_clear_fifo()
835 readl(fsm->base + SPI_FAST_SEQ_DATA_REG); stfsm_clear_fifo()
837 dev_dbg(fsm->dev, "cleared %d byte(s) from the data FIFO\n", 4 - i); stfsm_clear_fifo()
840 static int stfsm_write_fifo(struct stfsm *fsm, const uint32_t *buf, stfsm_write_fifo() argument
845 dev_dbg(fsm->dev, "writing %d bytes to FIFO\n", size); stfsm_write_fifo()
849 writesl(fsm->base + SPI_FAST_SEQ_DATA_REG, buf, words); stfsm_write_fifo()
854 static int stfsm_enter_32bit_addr(struct stfsm *fsm, int enter) stfsm_enter_32bit_addr() argument
856 struct stfsm_seq *seq = &fsm->stfsm_seq_en_32bit_addr; stfsm_enter_32bit_addr()
864 stfsm_load_seq(fsm, seq); stfsm_enter_32bit_addr()
866 stfsm_wait_seq(fsm); stfsm_enter_32bit_addr()
871 static uint8_t stfsm_wait_busy(struct stfsm *fsm) stfsm_wait_busy() argument
884 stfsm_load_seq(fsm, seq); stfsm_wait_busy()
894 stfsm_wait_seq(fsm); stfsm_wait_busy()
896 stfsm_read_fifo(fsm, &status, 4); stfsm_wait_busy()
901 if ((fsm->configuration & CFG_S25FL_CHECK_ERROR_FLAGS) && stfsm_wait_busy()
908 writel(seq->seq_cfg, fsm->base + SPI_FAST_SEQ_CFG); stfsm_wait_busy()
913 dev_err(fsm->dev, "timeout on wait_busy\n"); stfsm_wait_busy()
918 static int stfsm_read_status(struct stfsm *fsm, uint8_t cmd, stfsm_read_status() argument
926 dev_dbg(fsm->dev, "read 'status' register [0x%02x], %d byte(s)\n", stfsm_read_status()
934 stfsm_load_seq(fsm, seq); stfsm_read_status()
936 stfsm_read_fifo(fsm, &tmp, 4); stfsm_read_status()
941 stfsm_wait_seq(fsm); stfsm_read_status()
946 static int stfsm_write_status(struct stfsm *fsm, uint8_t cmd, stfsm_write_status() argument
951 dev_dbg(fsm->dev, stfsm_write_status()
963 stfsm_load_seq(fsm, seq); stfsm_write_status()
965 stfsm_wait_seq(fsm); stfsm_write_status()
968 stfsm_wait_busy(fsm); stfsm_write_status()
993 static bool stfsm_can_handle_soc_reset(struct stfsm *fsm) stfsm_can_handle_soc_reset() argument
996 if (fsm->reset_signal && fsm->info->flags & FLASH_FLAG_RESET) stfsm_can_handle_soc_reset()
1000 if (fsm->reset_por) stfsm_can_handle_soc_reset()
1008 static void stfsm_prepare_erasesec_seq(struct stfsm *fsm, stfsm_prepare_erasesec_seq() argument
1011 int addr1_cycles = fsm->info->flags & FLASH_FLAG_32BIT_ADDR ? 16 : 8; stfsm_prepare_erasesec_seq()
1022 stfsm_search_seq_rw_configs(struct stfsm *fsm, stfsm_search_seq_rw_configs() argument
1026 int flags = fsm->info->flags; stfsm_search_seq_rw_configs()
1036 static void stfsm_prepare_rw_seq(struct stfsm *fsm, stfsm_prepare_rw_seq() argument
1058 addr1_cycles = (fsm->info->flags & FLASH_FLAG_32BIT_ADDR) ? 16 : 8; stfsm_prepare_rw_seq()
1104 static int stfsm_search_prepare_rw_seq(struct stfsm *fsm, stfsm_search_prepare_rw_seq() argument
1110 config = stfsm_search_seq_rw_configs(fsm, cfgs); stfsm_search_prepare_rw_seq()
1112 dev_err(fsm->dev, "failed to find suitable config\n"); stfsm_search_prepare_rw_seq()
1116 stfsm_prepare_rw_seq(fsm, seq, config); stfsm_search_prepare_rw_seq()
1122 static int stfsm_prepare_rwe_seqs_default(struct stfsm *fsm) stfsm_prepare_rwe_seqs_default() argument
1124 uint32_t flags = fsm->info->flags; stfsm_prepare_rwe_seqs_default()
1128 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read, stfsm_prepare_rwe_seqs_default()
1131 dev_err(fsm->dev, stfsm_prepare_rwe_seqs_default()
1138 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_write, stfsm_prepare_rwe_seqs_default()
1141 dev_err(fsm->dev, stfsm_prepare_rwe_seqs_default()
1148 stfsm_prepare_erasesec_seq(fsm, &stfsm_seq_erase_sector); stfsm_prepare_rwe_seqs_default()
1153 static int stfsm_mx25_config(struct stfsm *fsm) stfsm_mx25_config() argument
1155 uint32_t flags = fsm->info->flags; stfsm_mx25_config()
1164 ret = stfsm_prepare_rwe_seqs_default(fsm); stfsm_mx25_config()
1173 stfsm_mx25_en_32bit_addr_seq(&fsm->stfsm_seq_en_32bit_addr); stfsm_mx25_config()
1175 soc_reset = stfsm_can_handle_soc_reset(fsm); stfsm_mx25_config()
1176 if (soc_reset || !fsm->booted_from_spi) stfsm_mx25_config()
1179 stfsm_enter_32bit_addr(fsm, 1); stfsm_mx25_config()
1184 fsm->configuration = (CFG_READ_TOGGLE_32BIT_ADDR | stfsm_mx25_config()
1190 stfsm_read_status(fsm, SPINOR_OP_RDSR, &sta, 1); stfsm_mx25_config()
1191 data_pads = ((fsm->stfsm_seq_read.seq_cfg >> 16) & 0x3) + 1; stfsm_mx25_config()
1197 stfsm_write_status(fsm, SPINOR_OP_WRSR, sta, 1, 1); stfsm_mx25_config()
1204 stfsm_write_status(fsm, SPINOR_OP_WRSR, sta, 1, 1); stfsm_mx25_config()
1211 static int stfsm_n25q_config(struct stfsm *fsm) stfsm_n25q_config() argument
1213 uint32_t flags = fsm->info->flags; stfsm_n25q_config()
1220 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read, stfsm_n25q_config()
1223 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read, stfsm_n25q_config()
1226 dev_err(fsm->dev, stfsm_n25q_config()
1233 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_write, stfsm_n25q_config()
1236 dev_err(fsm->dev, stfsm_n25q_config()
1243 stfsm_prepare_erasesec_seq(fsm, &stfsm_seq_erase_sector); stfsm_n25q_config()
1247 stfsm_n25q_en_32bit_addr_seq(&fsm->stfsm_seq_en_32bit_addr); stfsm_n25q_config()
1249 soc_reset = stfsm_can_handle_soc_reset(fsm); stfsm_n25q_config()
1250 if (soc_reset || !fsm->booted_from_spi) { stfsm_n25q_config()
1255 stfsm_enter_32bit_addr(fsm, 1); stfsm_n25q_config()
1261 fsm->configuration = (CFG_WRITE_TOGGLE_32BIT_ADDR | stfsm_n25q_config()
1271 stfsm_write_status(fsm, N25Q_CMD_WRVCR, vcr, 1, 0); stfsm_n25q_config()
1289 static void stfsm_s25fl_read_dyb(struct stfsm *fsm, uint32_t offs, uint8_t *dby) stfsm_s25fl_read_dyb() argument
1316 stfsm_load_seq(fsm, &seq); stfsm_s25fl_read_dyb()
1318 stfsm_read_fifo(fsm, &tmp, 4); stfsm_s25fl_read_dyb()
1322 stfsm_wait_seq(fsm); stfsm_s25fl_read_dyb()
1325 static void stfsm_s25fl_write_dyb(struct stfsm *fsm, uint32_t offs, uint8_t dby) stfsm_s25fl_write_dyb() argument
1354 stfsm_load_seq(fsm, &seq); stfsm_s25fl_write_dyb()
1355 stfsm_wait_seq(fsm); stfsm_s25fl_write_dyb()
1357 stfsm_wait_busy(fsm); stfsm_s25fl_write_dyb()
1360 static int stfsm_s25fl_clear_status_reg(struct stfsm *fsm) stfsm_s25fl_clear_status_reg() argument
1384 stfsm_load_seq(fsm, &seq); stfsm_s25fl_clear_status_reg()
1386 stfsm_wait_seq(fsm); stfsm_s25fl_clear_status_reg()
1391 static int stfsm_s25fl_config(struct stfsm *fsm) stfsm_s25fl_config() argument
1393 struct flash_info *info = fsm->info; stfsm_s25fl_config()
1407 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read, stfsm_s25fl_config()
1412 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_write, stfsm_s25fl_config()
1421 ret = stfsm_prepare_rwe_seqs_default(fsm); stfsm_s25fl_config()
1434 stfsm_s25fl_read_dyb(fsm, offs, &dyb); stfsm_s25fl_config()
1436 stfsm_s25fl_write_dyb(fsm, offs, 0xff); stfsm_s25fl_config()
1448 stfsm_read_status(fsm, SPINOR_OP_RDSR2, &cr1, 1); stfsm_s25fl_config()
1449 data_pads = ((fsm->stfsm_seq_read.seq_cfg >> 16) & 0x3) + 1; stfsm_s25fl_config()
1466 stfsm_read_status(fsm, SPINOR_OP_RDSR, &sr1, 1); stfsm_s25fl_config()
1468 stfsm_write_status(fsm, SPINOR_OP_WRSR, sta_wr, 2, 1); stfsm_s25fl_config()
1475 fsm->configuration |= CFG_S25FL_CHECK_ERROR_FLAGS; stfsm_s25fl_config()
1480 static int stfsm_w25q_config(struct stfsm *fsm) stfsm_w25q_config() argument
1488 ret = stfsm_prepare_rwe_seqs_default(fsm); stfsm_w25q_config()
1493 stfsm_read_status(fsm, SPINOR_OP_RDSR2, &sr2, 1); stfsm_w25q_config()
1494 data_pads = ((fsm->stfsm_seq_read.seq_cfg >> 16) & 0x3) + 1; stfsm_w25q_config()
1510 stfsm_read_status(fsm, SPINOR_OP_RDSR, &sr1, 1); stfsm_w25q_config()
1512 stfsm_write_status(fsm, SPINOR_OP_WRSR, sr_wr, 2, 1); stfsm_w25q_config()
1518 static int stfsm_read(struct stfsm *fsm, uint8_t *buf, uint32_t size, stfsm_read() argument
1521 struct stfsm_seq *seq = &fsm->stfsm_seq_read; stfsm_read()
1531 dev_dbg(fsm->dev, "reading %d bytes from 0x%08x\n", size, offset); stfsm_read()
1534 if (fsm->configuration & CFG_READ_TOGGLE_32BIT_ADDR) stfsm_read()
1535 stfsm_enter_32bit_addr(fsm, 1); stfsm_read()
1553 stfsm_load_seq(fsm, seq); stfsm_read()
1556 stfsm_read_fifo(fsm, (uint32_t *)p, size_lb); stfsm_read()
1559 stfsm_read_fifo(fsm, tmp, read_mask + 1); stfsm_read()
1568 stfsm_wait_seq(fsm); stfsm_read()
1570 stfsm_clear_fifo(fsm); stfsm_read()
1573 if (fsm->configuration & CFG_READ_TOGGLE_32BIT_ADDR) stfsm_read()
1574 stfsm_enter_32bit_addr(fsm, 0); stfsm_read()
1579 static int stfsm_write(struct stfsm *fsm, const uint8_t *buf, stfsm_write() argument
1582 struct stfsm_seq *seq = &fsm->stfsm_seq_write; stfsm_write()
1595 dev_dbg(fsm->dev, "writing %d bytes to 0x%08x\n", size, offset); stfsm_write()
1598 if (fsm->configuration & CFG_WRITE_TOGGLE_32BIT_ADDR) stfsm_write()
1599 stfsm_enter_32bit_addr(fsm, 1); stfsm_write()
1625 writel(0x00040000, fsm->base + SPI_FAST_SEQ_CFG); stfsm_write()
1631 if (fsm->fifo_dir_delay == 0) stfsm_write()
1632 readl(fsm->base + SPI_FAST_SEQ_CFG); stfsm_write()
1634 udelay(fsm->fifo_dir_delay); stfsm_write()
1639 stfsm_write_fifo(fsm, (uint32_t *)p, size_lb); stfsm_write()
1649 stfsm_write_fifo(fsm, tmp, write_mask + 1); stfsm_write()
1653 stfsm_load_seq(fsm, seq); stfsm_write()
1656 stfsm_wait_seq(fsm); stfsm_write()
1659 ret = stfsm_wait_busy(fsm); stfsm_write()
1660 if (ret && fsm->configuration & CFG_S25FL_CHECK_ERROR_FLAGS) stfsm_write()
1661 stfsm_s25fl_clear_status_reg(fsm); stfsm_write()
1664 if (fsm->configuration & CFG_WRITE_TOGGLE_32BIT_ADDR) stfsm_write()
1665 stfsm_enter_32bit_addr(fsm, 0); stfsm_write()
1677 struct stfsm *fsm = dev_get_drvdata(mtd->dev.parent); stfsm_mtd_read() local
1680 dev_dbg(fsm->dev, "%s from 0x%08x, len %zd\n", stfsm_mtd_read()
1683 mutex_lock(&fsm->lock); stfsm_mtd_read()
1688 stfsm_read(fsm, buf, bytes, from); stfsm_mtd_read()
1697 mutex_unlock(&fsm->lock); stfsm_mtd_read()
1702 static int stfsm_erase_sector(struct stfsm *fsm, uint32_t offset) stfsm_erase_sector() argument
1707 dev_dbg(fsm->dev, "erasing sector at 0x%08x\n", offset); stfsm_erase_sector()
1710 if (fsm->configuration & CFG_ERASESEC_TOGGLE_32BIT_ADDR) stfsm_erase_sector()
1711 stfsm_enter_32bit_addr(fsm, 1); stfsm_erase_sector()
1716 stfsm_load_seq(fsm, seq); stfsm_erase_sector()
1718 stfsm_wait_seq(fsm); stfsm_erase_sector()
1721 ret = stfsm_wait_busy(fsm); stfsm_erase_sector()
1722 if (ret && fsm->configuration & CFG_S25FL_CHECK_ERROR_FLAGS) stfsm_erase_sector()
1723 stfsm_s25fl_clear_status_reg(fsm); stfsm_erase_sector()
1726 if (fsm->configuration & CFG_ERASESEC_TOGGLE_32BIT_ADDR) stfsm_erase_sector()
1727 stfsm_enter_32bit_addr(fsm, 0); stfsm_erase_sector()
1732 static int stfsm_erase_chip(struct stfsm *fsm) stfsm_erase_chip() argument
1736 dev_dbg(fsm->dev, "erasing chip\n"); stfsm_erase_chip()
1738 stfsm_load_seq(fsm, seq); stfsm_erase_chip()
1740 stfsm_wait_seq(fsm); stfsm_erase_chip()
1742 return stfsm_wait_busy(fsm); stfsm_erase_chip()
1753 struct stfsm *fsm = dev_get_drvdata(mtd->dev.parent); stfsm_mtd_write() local
1760 dev_dbg(fsm->dev, "%s to 0x%08x, len %zd\n", __func__, (u32)to, len); stfsm_mtd_write()
1765 mutex_lock(&fsm->lock); stfsm_mtd_write()
1771 ret = stfsm_write(fsm, b, bytes, to); stfsm_mtd_write()
1787 mutex_unlock(&fsm->lock); stfsm_mtd_write()
1798 struct stfsm *fsm = dev_get_drvdata(mtd->dev.parent); stfsm_mtd_erase() local
1802 dev_dbg(fsm->dev, "%s at 0x%llx, len %lld\n", __func__, stfsm_mtd_erase()
1808 mutex_lock(&fsm->lock); stfsm_mtd_erase()
1812 ret = stfsm_erase_chip(fsm); stfsm_mtd_erase()
1817 ret = stfsm_erase_sector(fsm, addr); stfsm_mtd_erase()
1826 mutex_unlock(&fsm->lock); stfsm_mtd_erase()
1835 mutex_unlock(&fsm->lock); stfsm_mtd_erase()
1840 static void stfsm_read_jedec(struct stfsm *fsm, uint8_t *jedec) stfsm_read_jedec() argument
1845 stfsm_load_seq(fsm, seq); stfsm_read_jedec()
1847 stfsm_read_fifo(fsm, tmp, 8); stfsm_read_jedec()
1851 stfsm_wait_seq(fsm); stfsm_read_jedec()
1854 static struct flash_info *stfsm_jedec_probe(struct stfsm *fsm) stfsm_jedec_probe() argument
1861 stfsm_read_jedec(fsm, id); stfsm_jedec_probe()
1871 dev_dbg(fsm->dev, "JEDEC = 0x%08x [%02x %02x %02x %02x %02x]\n", stfsm_jedec_probe()
1881 dev_err(fsm->dev, "Unrecognized JEDEC id %06x\n", jedec); stfsm_jedec_probe()
1886 static int stfsm_set_mode(struct stfsm *fsm, uint32_t mode) stfsm_set_mode() argument
1892 ret = readl(fsm->base + SPI_STA_MODE_CHANGE); stfsm_set_mode()
1901 writel(mode, fsm->base + SPI_MODESELECT); stfsm_set_mode()
1906 static void stfsm_set_freq(struct stfsm *fsm, uint32_t spi_freq) stfsm_set_freq() argument
1911 emi_freq = clk_get_rate(fsm->clk); stfsm_set_freq()
1930 fsm->fifo_dir_delay = 0; stfsm_set_freq()
1932 fsm->fifo_dir_delay = 1; stfsm_set_freq()
1934 fsm->fifo_dir_delay = DIV_ROUND_UP(clk_div, 10); stfsm_set_freq()
1936 dev_dbg(fsm->dev, "emi_clk = %uHZ, spi_freq = %uHZ, clk_div = %u\n", stfsm_set_freq()
1939 writel(clk_div, fsm->base + SPI_CLOCKDIV); stfsm_set_freq()
1942 static int stfsm_init(struct stfsm *fsm) stfsm_init() argument
1947 writel(SEQ_CFG_SWRESET, fsm->base + SPI_FAST_SEQ_CFG); stfsm_init()
1949 writel(0, fsm->base + SPI_FAST_SEQ_CFG); stfsm_init()
1952 stfsm_set_freq(fsm, STFSM_FLASH_SAFE_FREQ); stfsm_init()
1955 ret = stfsm_set_mode(fsm, SPI_MODESELECT_FSM); stfsm_init()
1964 fsm->base + SPI_CONFIGDATA); stfsm_init()
1965 writel(STFSM_DEFAULT_WR_TIME, fsm->base + SPI_STATUS_WR_TIME_REG); stfsm_init()
1972 writel(0x00000001, fsm->base + SPI_PROGRAM_ERASE_TIME); stfsm_init()
1975 stfsm_clear_fifo(fsm); stfsm_init()
1982 struct stfsm *fsm = platform_get_drvdata(pdev); stfsm_fetch_platform_configs() local
1991 fsm->booted_from_spi = true; stfsm_fetch_platform_configs()
1997 fsm->reset_signal = of_property_read_bool(np, "st,reset-signal"); stfsm_fetch_platform_configs()
1999 fsm->reset_por = of_property_read_bool(np, "st,reset-por"); stfsm_fetch_platform_configs()
2016 fsm->booted_from_spi = false; stfsm_fetch_platform_configs()
2031 struct stfsm *fsm; stfsm_probe() local
2040 fsm = devm_kzalloc(&pdev->dev, sizeof(*fsm), GFP_KERNEL); stfsm_probe()
2041 if (!fsm) stfsm_probe()
2044 fsm->dev = &pdev->dev; stfsm_probe()
2046 platform_set_drvdata(pdev, fsm); stfsm_probe()
2054 fsm->base = devm_ioremap_resource(&pdev->dev, res); stfsm_probe()
2055 if (IS_ERR(fsm->base)) { stfsm_probe()
2058 return PTR_ERR(fsm->base); stfsm_probe()
2061 fsm->clk = devm_clk_get(&pdev->dev, NULL); stfsm_probe()
2062 if (IS_ERR(fsm->clk)) { stfsm_probe()
2063 dev_err(fsm->dev, "Couldn't find EMI clock.\n"); stfsm_probe()
2064 return PTR_ERR(fsm->clk); stfsm_probe()
2067 ret = clk_prepare_enable(fsm->clk); stfsm_probe()
2069 dev_err(fsm->dev, "Failed to enable EMI clock.\n"); stfsm_probe()
2073 mutex_init(&fsm->lock); stfsm_probe()
2075 ret = stfsm_init(fsm); stfsm_probe()
2084 info = stfsm_jedec_probe(fsm); stfsm_probe()
2087 fsm->info = info; stfsm_probe()
2098 ret = info->config(fsm); stfsm_probe()
2102 ret = stfsm_prepare_rwe_seqs_default(fsm); stfsm_probe()
2107 fsm->mtd.name = info->name; stfsm_probe()
2108 fsm->mtd.dev.parent = &pdev->dev; stfsm_probe()
2109 fsm->mtd.type = MTD_NORFLASH; stfsm_probe()
2110 fsm->mtd.writesize = 4; stfsm_probe()
2111 fsm->mtd.writebufsize = fsm->mtd.writesize; stfsm_probe()
2112 fsm->mtd.flags = MTD_CAP_NORFLASH; stfsm_probe()
2113 fsm->mtd.size = info->sector_size * info->n_sectors; stfsm_probe()
2114 fsm->mtd.erasesize = info->sector_size; stfsm_probe()
2116 fsm->mtd._read = stfsm_mtd_read; stfsm_probe()
2117 fsm->mtd._write = stfsm_mtd_write; stfsm_probe()
2118 fsm->mtd._erase = stfsm_mtd_erase; stfsm_probe()
2124 (long long)fsm->mtd.size, (long long)(fsm->mtd.size >> 20), stfsm_probe()
2125 fsm->mtd.erasesize, (fsm->mtd.erasesize >> 10)); stfsm_probe()
2127 return mtd_device_parse_register(&fsm->mtd, NULL, &ppdata, NULL, 0); stfsm_probe()
2132 struct stfsm *fsm = platform_get_drvdata(pdev); stfsm_remove() local
2134 return mtd_device_unregister(&fsm->mtd); stfsm_remove()
2140 struct stfsm *fsm = dev_get_drvdata(dev); stfsmfsm_suspend() local
2142 clk_disable_unprepare(fsm->clk); stfsmfsm_suspend()
2149 struct stfsm *fsm = dev_get_drvdata(dev); stfsmfsm_resume() local
2151 clk_prepare_enable(fsm->clk); stfsmfsm_resume()
2160 { .compatible = "st,spi-fsm", },
2169 .name = "st-spi-fsm",
/linux-4.4.14/drivers/isdn/mISDN/
H A Dfsm.c25 #include "fsm.h"
30 mISDN_FsmNew(struct Fsm *fsm, mISDN_FsmNew() argument
35 fsm->jumpmatrix = kzalloc(sizeof(FSMFNPTR) * fsm->state_count * mISDN_FsmNew()
36 fsm->event_count, GFP_KERNEL); mISDN_FsmNew()
39 if ((fnlist[i].state >= fsm->state_count) || mISDN_FsmNew()
40 (fnlist[i].event >= fsm->event_count)) { mISDN_FsmNew()
43 i, (long)fnlist[i].state, (long)fsm->state_count, mISDN_FsmNew()
44 (long)fnlist[i].event, (long)fsm->event_count); mISDN_FsmNew()
46 fsm->jumpmatrix[fsm->state_count * fnlist[i].event + mISDN_FsmNew()
52 mISDN_FsmFree(struct Fsm *fsm) mISDN_FsmFree() argument
54 kfree((void *) fsm->jumpmatrix); mISDN_FsmFree()
63 if ((fi->state >= fi->fsm->state_count) || mISDN_FsmEvent()
64 (event >= fi->fsm->event_count)) { mISDN_FsmEvent()
67 (long)fi->state, (long)fi->fsm->state_count, event, mISDN_FsmEvent()
68 (long)fi->fsm->event_count); mISDN_FsmEvent()
71 r = fi->fsm->jumpmatrix[fi->fsm->state_count * event + fi->state]; mISDN_FsmEvent()
75 fi->fsm->strState[fi->state], mISDN_FsmEvent()
76 fi->fsm->strEvent[event]); mISDN_FsmEvent()
82 fi->fsm->strState[fi->state], mISDN_FsmEvent()
83 fi->fsm->strEvent[event]); mISDN_FsmEvent()
95 fi->fsm->strState[newstate]); mISDN_FsmChangeState()
H A DMakefile11 mISDN_core-objs := core.o fsm.o socket.o clock.o hwchannel.o stack.o layer1.o layer2.o tei.o timerdev.o
H A Dfsm.h38 struct Fsm *fsm; member in struct:FsmInst
H A Dlayer2.h19 #include "fsm.h"
H A Dlayer1.c24 #include "fsm.h"
391 nl1->l1m.fsm = &l1fsm_s; create_l1()
H A Dtei.c826 l2->tm->tei_m.fsm = &teifsmn; create_new_tei()
1070 l2->tm->tei_m.fsm = &teifsmu; create_teimgr()
1078 l2->tm->tei_m.fsm = &teifsmn; create_teimgr()
1381 mgr->deact.fsm = &deactfsm; create_teimanager()
H A Dlayer2.c21 #include "fsm.h"
2209 l2->l2m.fsm = &l2fsm; create_l2()
/linux-4.4.14/drivers/usb/phy/
H A Dphy-fsl-usb.c123 void fsl_otg_chrg_vbus(struct otg_fsm *fsm, int on) fsl_otg_chrg_vbus() argument
159 void fsl_otg_drv_vbus(struct otg_fsm *fsm, int on) fsl_otg_drv_vbus() argument
177 void fsl_otg_loc_conn(struct otg_fsm *fsm, int on) fsl_otg_loc_conn() argument
196 void fsl_otg_loc_sof(struct otg_fsm *fsm, int on) fsl_otg_loc_sof() argument
211 void fsl_otg_start_pulse(struct otg_fsm *fsm) fsl_otg_start_pulse() argument
224 fsl_otg_add_timer(fsm, b_data_pulse_tmr); fsl_otg_start_pulse()
241 fsl_otg_chrg_vbus(&fsl_otg_dev->fsm, 1); fsl_otg_pulse_vbus()
243 fsl_otg_add_timer(&fsl_otg_dev->fsm, b_vbus_pulse_tmr); fsl_otg_pulse_vbus()
248 fsl_otg_chrg_vbus(&fsl_otg_dev->fsm, 0); b_vbus_pulse_end()
256 fsl_otg_add_timer(&fsl_otg_dev->fsm, b_srp_wait_tmr); b_vbus_pulse_end()
265 fsl_otg_dev->fsm.b_sess_vld) b_srp_end()
266 fsl_otg_dev->fsm.b_srp_done = 1; b_srp_end()
278 fsl_otg_add_timer(&fsl_otg_dev->fsm, a_wait_enum_tmr); a_wait_enum()
280 otg_statemachine(&fsl_otg_dev->fsm); a_wait_enum()
290 int fsl_otg_init_timers(struct otg_fsm *fsm) fsl_otg_init_timers() argument
294 (unsigned long)&fsm->a_wait_vrise_tmout); fsl_otg_init_timers()
299 (unsigned long)&fsm->a_wait_bcon_tmout); fsl_otg_init_timers()
304 (unsigned long)&fsm->a_aidl_bdis_tmout); fsl_otg_init_timers()
309 (unsigned long)&fsm->b_ase0_brst_tmout); fsl_otg_init_timers()
314 (unsigned long)&fsm->b_se0_srp); fsl_otg_init_timers()
319 (unsigned long)&fsm->b_srp_done); fsl_otg_init_timers()
324 (unsigned long)&fsm); fsl_otg_init_timers()
399 void fsl_otg_add_timer(struct otg_fsm *fsm, void *gtimer) fsl_otg_add_timer() argument
417 static void fsl_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t) fsl_otg_fsm_add_timer() argument
425 fsl_otg_add_timer(fsm, timer); fsl_otg_fsm_add_timer()
429 void fsl_otg_del_timer(struct otg_fsm *fsm, void *gtimer) fsl_otg_del_timer() argument
439 static void fsl_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t) fsl_otg_fsm_del_timer() argument
447 fsl_otg_del_timer(fsm, timer); fsl_otg_fsm_del_timer()
463 int fsl_otg_start_host(struct otg_fsm *fsm, int on) fsl_otg_start_host() argument
465 struct usb_otg *otg = fsm->otg; fsl_otg_start_host()
479 fsm->a_vbus_vld = fsl_otg_start_host()
490 if (fsm->id) { fsl_otg_start_host()
492 fsl_otg_drv_vbus(fsm, 1); fsl_otg_start_host()
515 if (fsm->id) fsl_otg_start_host()
517 fsl_otg_drv_vbus(fsm, 0); fsl_otg_start_host()
530 int fsl_otg_start_gadget(struct otg_fsm *fsm, int on) fsl_otg_start_gadget() argument
532 struct usb_otg *otg = fsm->otg; fsl_otg_start_gadget()
569 otg_dev->fsm.a_bus_drop = 0; fsl_otg_set_host()
570 otg_dev->fsm.a_bus_req = 1; fsl_otg_set_host()
576 otg->host->is_b_host = otg_dev->fsm.id; fsl_otg_set_host()
590 struct otg_fsm *fsm = &otg_dev->fsm; fsl_otg_set_host() local
593 fsm->protocol = PROTO_UNDEF; fsl_otg_set_host()
599 otg_statemachine(&otg_dev->fsm); fsl_otg_set_host()
624 otg_dev->fsm.b_bus_req = 0; fsl_otg_set_peripheral()
625 otg_statemachine(&otg_dev->fsm); fsl_otg_set_peripheral()
630 otg->gadget->is_a_peripheral = !otg_dev->fsm.id; fsl_otg_set_peripheral()
632 otg_dev->fsm.b_bus_req = 1; fsl_otg_set_peripheral()
635 pr_debug("ID pin=%d\n", otg_dev->fsm.id); fsl_otg_set_peripheral()
636 if (otg_dev->fsm.id == 1) { fsl_otg_set_peripheral()
637 fsl_otg_start_host(&otg_dev->fsm, 0); fsl_otg_set_peripheral()
638 otg_drv_vbus(&otg_dev->fsm, 0); fsl_otg_set_peripheral()
639 fsl_otg_start_gadget(&otg_dev->fsm, 1); fsl_otg_set_peripheral()
669 struct otg_fsm *fsm = &og->fsm; fsl_otg_event() local
671 if (fsm->id) { /* switch to gadget */ fsl_otg_event()
672 fsl_otg_start_host(fsm, 0); fsl_otg_event()
673 otg_drv_vbus(fsm, 0); fsl_otg_event()
674 fsl_otg_start_gadget(fsm, 1); fsl_otg_event()
690 otg_dev->fsm.b_bus_req = 1; fsl_otg_start_srp()
691 otg_statemachine(&otg_dev->fsm); fsl_otg_start_srp()
711 otg_dev->fsm.a_bus_req = 0; fsl_otg_start_hnp()
712 otg_statemachine(&otg_dev->fsm); fsl_otg_start_hnp()
725 struct otg_fsm *fsm = &((struct fsl_otg *)dev_id)->fsm; fsl_otg_isr() local
736 fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0; fsl_otg_isr()
737 otg->default_a = (fsm->id == 0); fsl_otg_isr()
742 fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0; fsl_otg_isr()
743 otg->default_a = (fsm->id == 0); fsl_otg_isr()
745 if (fsm->id) fsl_otg_isr()
746 fsm->b_conn = 0; fsl_otg_isr()
748 fsm->a_conn = 0; fsl_otg_isr()
751 otg->host->is_b_host = fsm->id; fsl_otg_isr()
753 otg->gadget->is_a_peripheral = !fsm->id; fsl_otg_isr()
754 VDBG("ID int (ID is %d)\n", fsm->id); fsl_otg_isr()
756 if (fsm->id) { /* switch to gadget */ fsl_otg_isr()
764 fsl_otg_start_gadget(fsm, 0); fsl_otg_isr()
765 otg_drv_vbus(fsm, 1); fsl_otg_isr()
766 fsl_otg_start_host(fsm, 1); fsl_otg_isr()
811 status = fsl_otg_init_timers(&fsl_otg_tc->fsm); fsl_otg_conf()
816 mutex_init(&fsl_otg_tc->fsm.lock); fsl_otg_conf()
819 fsl_otg_tc->fsm.ops = &fsl_otg_ops; fsl_otg_conf()
854 struct otg_fsm *fsm; usb_otg_start() local
861 fsm = &p_otg->fsm; usb_otg_start()
865 fsm->otg = p_otg->phy.otg; usb_otg_start()
959 p_otg->fsm.id = 1; usb_otg_start()
962 p_otg->fsm.id = 0; usb_otg_start()
965 pr_debug("initial ID pin=%d\n", p_otg->fsm.id); usb_otg_start()
982 struct otg_fsm *fsm = &fsl_otg_dev->fsm; show_fsl_usb2_otg_state() local
987 mutex_lock(&fsm->lock); show_fsl_usb2_otg_state()
1037 fsm->a_bus_req, show_fsl_usb2_otg_state()
1038 fsm->b_bus_req, show_fsl_usb2_otg_state()
1039 fsm->a_bus_resume, show_fsl_usb2_otg_state()
1040 fsm->a_bus_suspend, show_fsl_usb2_otg_state()
1041 fsm->a_conn, show_fsl_usb2_otg_state()
1042 fsm->a_sess_vld, show_fsl_usb2_otg_state()
1043 fsm->a_srp_det, show_fsl_usb2_otg_state()
1044 fsm->a_vbus_vld, show_fsl_usb2_otg_state()
1045 fsm->b_bus_resume, show_fsl_usb2_otg_state()
1046 fsm->b_bus_suspend, show_fsl_usb2_otg_state()
1047 fsm->b_conn, show_fsl_usb2_otg_state()
1048 fsm->b_se0_srp, show_fsl_usb2_otg_state()
1049 fsm->b_ssend_srp, show_fsl_usb2_otg_state()
1050 fsm->b_sess_vld, show_fsl_usb2_otg_state()
1051 fsm->id); show_fsl_usb2_otg_state()
1055 mutex_unlock(&fsm->lock); show_fsl_usb2_otg_state()
1080 fsl_otg_dev->fsm.a_suspend_req_inf = arg; fsl_otg_ioctl()
1084 fsl_otg_dev->fsm.a_bus_drop = arg; fsl_otg_ioctl()
1088 fsl_otg_dev->fsm.a_bus_req = arg; fsl_otg_ioctl()
1092 fsl_otg_dev->fsm.b_bus_req = arg; fsl_otg_ioctl()
1099 otg_statemachine(&fsl_otg_dev->fsm); fsl_otg_ioctl()
H A Dphy-fsl-usb.h18 #include <linux/usb/otg-fsm.h>
373 struct otg_fsm fsm; member in struct:fsl_otg
404 void fsl_otg_add_timer(struct otg_fsm *fsm, void *timer);
405 void fsl_otg_del_timer(struct otg_fsm *fsm, void *timer);
H A Dphy-isp1301-omap.c415 u8 fsm = omap_readw(OTG_TEST) & 0x0ff; check_state() local
418 switch (fsm) { check_state()
480 usb_otg_state_string(state), fsm, state_name(isp), check_state()
/linux-4.4.14/drivers/s390/net/
H A Dfsm.c2 * A generic FSM based on fsm used in isdn4linux
6 #include "fsm.h"
22 fsm *f; init_fsm()
27 "fsm(%s): init_fsm: Couldn't alloc instance\n", name); init_fsm()
33 f = kzalloc(sizeof(fsm), order); init_fsm()
36 "fsm(%s): init_fsm: Couldn't alloc fsm\n", name); init_fsm()
49 "fsm(%s): init_fsm: Couldn't alloc jumptable\n", name); init_fsm()
59 "fsm(%s): init_fsm: Bad template l=%d st(%ld/%ld) ev(%ld/%ld)\n", init_fsm()
82 "fsm: kfree_fsm called with NULL argument\n"); kfree_fsm()
95 printk(KERN_DEBUG "fsm(%s): History:\n", fi->name); fsm_print_history()
135 printk(KERN_DEBUG "fsm(%s): Timer %p expired\n", fsm_expire_timer()
148 printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name, fsm_settimer()
158 printk(KERN_DEBUG "fsm(%s): Delete timer %p\n", this->fi->name, fsm_deltimer()
169 printk(KERN_DEBUG "fsm(%s): Add timer %p %dms\n", fsm_addtimer()
189 printk(KERN_DEBUG "fsm(%s): Restart timer %p %dms\n", fsm_modtimer()
H A Dctcm_mpc.c111 static void mpc_action_nop(fsm_instance *fsm, int event, void *arg);
112 static void mpc_action_go_ready(fsm_instance *fsm, int event, void *arg);
116 static void mpc_action_yside_xid(fsm_instance *fsm, int event, void *arg);
117 static void mpc_action_doxid0(fsm_instance *fsm, int event, void *arg);
118 static void mpc_action_doxid7(fsm_instance *fsm, int event, void *arg);
119 static void mpc_action_xside_xid(fsm_instance *fsm, int event, void *arg);
120 static void mpc_action_rcvd_xid0(fsm_instance *fsm, int event, void *arg);
121 static void mpc_action_rcvd_xid7(fsm_instance *fsm, int event, void *arg);
344 CTCM_FUNTAIL, dev->name, fsm_getstate_str(grp->fsm)); ctc_mpc_alloc_channel()
346 switch (fsm_getstate(grp->fsm)) { ctc_mpc_alloc_channel()
356 /*fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW);*/ ctc_mpc_alloc_channel()
367 fsm_event(priv->fsm, DEV_EVENT_START, dev); ctc_mpc_alloc_channel()
381 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctc_mpc_alloc_channel()
413 CTCM_FUNTAIL, dev->name, fsm_getstate_str(grp->fsm)); ctc_mpc_establish_connectivity()
418 switch (fsm_getstate(grp->fsm)) { ctc_mpc_establish_connectivity()
433 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctc_mpc_establish_connectivity()
455 if ((fsm_getstate(rch->fsm) > CH_XID0_PENDING) || ctc_mpc_establish_connectivity()
456 (fsm_getstate(wch->fsm) > CH_XID0_PENDING)) { ctc_mpc_establish_connectivity()
463 fsm_newstate(grp->fsm, MPCG_STATE_XID0IOWAIT); ctc_mpc_establish_connectivity()
471 (fsm_getstate(rch->fsm) == CH_XID0_PENDING)) ctc_mpc_establish_connectivity()
472 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, rch); ctc_mpc_establish_connectivity()
485 (fsm_getstate(wch->fsm) == CH_XID0_PENDING)) ctc_mpc_establish_connectivity()
486 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, wch); ctc_mpc_establish_connectivity()
538 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctc_mpc_dealloc_ch()
569 mpcg_state = fsm_getstate(grp->fsm); ctc_mpc_flow_control()
578 fsm_newstate(grp->fsm, MPCG_STATE_FLOWC); ctc_mpc_flow_control()
584 fsm_newstate(grp->fsm, MPCG_STATE_READY); ctc_mpc_flow_control()
684 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_send_sweep_resp()
827 static void mpc_action_go_ready(fsm_instance *fsm, int event, void *arg) mpc_action_go_ready() argument
851 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); mpc_action_go_ready()
889 fsm_newstate(grp->fsm, MPCG_STATE_READY); mpc_group_ready()
897 ctcmpc_chx_rxidle(ch->fsm, CTC_EVENT_START, ch); mpc_group_ready()
906 ctcm_chx_txidle(ch->fsm, CTC_EVENT_START, ch); mpc_group_ready()
925 * helper of dev_action (called from channel fsm)
945 fsm_getstate_str(grp->fsm), grp->num_channel_paths, mpc_channel_action()
964 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); mpc_channel_action()
992 fsm_newstate(ch->fsm, CH_XID0_PENDING); mpc_channel_action()
996 (fsm_getstate(grp->fsm) < MPCG_STATE_XID2INITW)) { mpc_channel_action()
997 fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW); mpc_channel_action()
1019 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); mpc_channel_action()
1025 fsm_getstate_str(grp->fsm), grp->num_channel_paths, mpc_channel_action()
1075 if ((fsm_getstate(grp->fsm) == MPCG_STATE_FLOWC) || ctcmpc_unpack_skb()
1076 ((fsm_getstate(grp->fsm) == MPCG_STATE_READY) && ctcmpc_unpack_skb()
1100 if (unlikely(fsm_getstate(grp->fsm) != MPCG_STATE_READY)) ctcmpc_unpack_skb()
1149 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_unpack_skb()
1199 fsm_event(grp->fsm, MPCG_EVENT_XID2, mpcginfo); ctcmpc_unpack_skb()
1201 fsm_event(grp->fsm, MPCG_EVENT_DISCONC, mpcginfo); ctcmpc_unpack_skb()
1220 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_unpack_skb()
1246 while ((fsm_getstate(grp->fsm) != MPCG_STATE_FLOWC) && ctcmpc_bh()
1254 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_bh()
1279 grp->fsm = init_fsm("mpcg", mpcg_state_names, mpcg_event_names, ctcmpc_init_mpc_group()
1282 if (grp->fsm == NULL) { ctcmpc_init_mpc_group()
1287 fsm_newstate(grp->fsm, MPCG_STATE_RESET); ctcmpc_init_mpc_group()
1288 fsm_settimer(grp->fsm, &grp->timer); ctcmpc_init_mpc_group()
1293 kfree_fsm(grp->fsm); ctcmpc_init_mpc_group()
1314 kfree_fsm(grp->fsm); ctcmpc_init_mpc_group()
1368 grp->saved_state = fsm_getstate(grp->fsm); mpc_action_go_inop()
1369 fsm_newstate(grp->fsm, MPCG_STATE_INOP); mpc_action_go_inop()
1430 fsm_newstate(grp->fsm, MPCG_STATE_RESET); mpc_action_go_inop()
1438 fsm_newstate(grp->fsm, MPCG_STATE_RESET); mpc_action_go_inop()
1450 * fi An instance of an mpc_group fsm.
1467 switch (fsm_getstate(grp->fsm)) { mpc_action_timeout()
1472 if ((fsm_getstate(rch->fsm) == CH_XID0_PENDING) && mpc_action_timeout()
1473 (fsm_getstate(wch->fsm) == CH_XID0_PENDING)) mpc_action_timeout()
1476 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); mpc_action_timeout()
1507 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); mpc_action_discontact()
1666 static void mpc_action_side_xid(fsm_instance *fsm, void *arg, int side) mpc_action_side_xid() argument
1824 static void mpc_action_xside_xid(fsm_instance *fsm, int event, void *arg) mpc_action_xside_xid() argument
1826 mpc_action_side_xid(fsm, arg, XSIDE); mpc_action_xside_xid()
1833 static void mpc_action_yside_xid(fsm_instance *fsm, int event, void *arg) mpc_action_yside_xid() argument
1835 mpc_action_side_xid(fsm, arg, YSIDE); mpc_action_yside_xid()
1842 static void mpc_action_doxid0(fsm_instance *fsm, int event, void *arg) mpc_action_doxid0() argument
1859 fsm_newstate(ch->fsm, CH_XID0_INPROGRESS); mpc_action_doxid0()
1863 switch (fsm_getstate(grp->fsm)) { mpc_action_doxid0()
1874 fsm_event(grp->fsm, MPCG_EVENT_DOIO, ch); mpc_action_doxid0()
1883 static void mpc_action_doxid7(fsm_instance *fsm, int event, void *arg) mpc_action_doxid7() argument
1908 if (fsm_getstate(ch->fsm) == CH_XID7_PENDING1) { mpc_action_doxid7()
1909 fsm_newstate(ch->fsm, CH_XID7_PENDING2); mpc_action_doxid7()
1916 } else if (fsm_getstate(ch->fsm) < CH_XID7_PENDING2) { mpc_action_doxid7()
1917 fsm_newstate(ch->fsm, CH_XID7_PENDING2); mpc_action_doxid7()
1927 if (fsm_getstate(ch->fsm) < CH_XID7_PENDING4) { mpc_action_doxid7()
1928 fsm_newstate(ch->fsm, CH_XID7_PENDING4); mpc_action_doxid7()
1935 } else if (fsm_getstate(ch->fsm) == CH_XID7_PENDING3) { mpc_action_doxid7()
1936 fsm_newstate(ch->fsm, CH_XID7_PENDING4); mpc_action_doxid7()
1945 fsm_event(grp->fsm, MPCG_EVENT_DOIO, ch); mpc_action_doxid7()
1955 static void mpc_action_rcvd_xid0(fsm_instance *fsm, int event, void *arg) mpc_action_rcvd_xid0() argument
1968 if (fsm_getstate(ch->fsm) < CH_XID7_PENDING) mpc_action_rcvd_xid0()
1969 fsm_newstate(ch->fsm, CH_XID7_PENDING); mpc_action_rcvd_xid0()
1977 switch (fsm_getstate(grp->fsm)) { mpc_action_rcvd_xid0()
1979 fsm_newstate(grp->fsm, MPCG_STATE_XID2INITX); mpc_action_rcvd_xid0()
1983 fsm_newstate(grp->fsm, MPCG_STATE_XID0IOWAIX); mpc_action_rcvd_xid0()
1988 fsm_newstate(grp->fsm, MPCG_STATE_XID7INITW); mpc_action_rcvd_xid0()
1990 fsm_event(grp->fsm, MPCG_EVENT_XID2DONE, dev); mpc_action_rcvd_xid0()
1995 fsm_newstate(grp->fsm, MPCG_STATE_XID7INITI); mpc_action_rcvd_xid0()
1997 fsm_event(grp->fsm, MPCG_EVENT_XID2DONE, dev); mpc_action_rcvd_xid0()
2008 fsm_getstate_str(grp->fsm), fsm_getstate_str(ch->fsm)); mpc_action_rcvd_xid0()
2018 static void mpc_action_rcvd_xid7(fsm_instance *fsm, int event, void *arg) mpc_action_rcvd_xid7() argument
2036 switch (fsm_getstate(grp->fsm)) { mpc_action_rcvd_xid7()
2038 fsm_newstate(grp->fsm, MPCG_STATE_XID7INITZ); mpc_action_rcvd_xid7()
2042 fsm_newstate(grp->fsm, MPCG_STATE_XID7INITX); mpc_action_rcvd_xid7()
2053 fsm_newstate(grp->fsm, MPCG_STATE_XID7INITF); mpc_action_rcvd_xid7()
2056 fsm_event(grp->fsm, MPCG_EVENT_XID7DONE, dev); mpc_action_rcvd_xid7()
H A Dctcm_main.c191 fsm_newstate(ch->fsm, CTC_STATE_IDLE); channel_free()
218 kfree_fsm(ch->fsm); channel_remove()
270 fsm_newstate(ch->fsm, CTC_STATE_STOPPED); channel_get()
322 fsm_event(ch->fsm, CTC_EVENT_UC_RCRESET, ch); ccw_unit_check()
330 fsm_event(ch->fsm, CTC_EVENT_UC_RSRESET, ch); ccw_unit_check()
340 fsm_event(ch->fsm, CTC_EVENT_UC_HWFAIL, ch); ccw_unit_check()
348 fsm_event(ch->fsm, CTC_EVENT_UC_RXPARITY, ch); ccw_unit_check()
358 fsm_event(ch->fsm, CTC_EVENT_UC_TXTIMEOUT, ch); ccw_unit_check()
360 fsm_event(ch->fsm, CTC_EVENT_UC_TXPARITY, ch); ccw_unit_check()
372 fsm_event(ch->fsm, CTC_EVENT_UC_ZERO, ch); ccw_unit_check()
377 fsm_event(ch->fsm, CTC_EVENT_UC_UNKNOWN, ch); ccw_unit_check()
430 fsm_event(priv->fsm, DEV_EVENT_START, dev); ctcm_open()
448 fsm_event(priv->fsm, DEV_EVENT_STOP, dev); ctcm_close()
479 if (fsm_getstate(ch->fsm) != CTC_STATE_TXIDLE) { ctcm_transmit_skb()
567 fsm_newstate(ch->fsm, CTC_STATE_TX); ctcm_transmit_skb()
655 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_send_sweep_req()
678 ch->id, fsm_getstate_str(ch->fsm)); ctcmpc_transmit_skb()
680 if ((fsm_getstate(ch->fsm) != CTC_STATE_TXIDLE) || grp->in_sweep) { ctcmpc_transmit_skb()
826 fsm_newstate(ch->fsm, CTC_STATE_TX); ctcmpc_transmit_skb()
860 fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev); ctcmpc_transmit_skb()
902 if (fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) { ctcm_tx()
903 fsm_event(priv->fsm, DEV_EVENT_START, dev); ctcm_tx()
958 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_tx()
973 if ((fsm_getstate(priv->fsm) != DEV_STATE_RUNNING) || ctcmpc_tx()
974 (fsm_getstate(grp->fsm) < MPCG_STATE_XID2INITW)) { ctcmpc_tx()
993 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_tx()
1007 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_tx()
1077 if (grp->fsm) ctcm_free_netdevice()
1078 kfree_fsm(grp->fsm); ctcm_free_netdevice()
1087 if (priv->fsm) { ctcm_free_netdevice()
1088 kfree_fsm(priv->fsm); ctcm_free_netdevice()
1089 priv->fsm = NULL; ctcm_free_netdevice()
1153 priv->fsm = init_fsm("ctcmdev", dev_state_names, dev_event_names, ctcm_init_netdevice()
1156 if (priv->fsm == NULL) { ctcm_init_netdevice()
1161 fsm_newstate(priv->fsm, DEV_STATE_STOPPED); ctcm_init_netdevice()
1162 fsm_settimer(priv->fsm, &priv->restart_timer); ctcm_init_netdevice()
1259 fsm_event(ch->fsm, CTC_EVENT_SC_UNKNOWN, ch); ctcm_irq_handler()
1280 fsm_event(ch->fsm, CTC_EVENT_ATTNBUSY, ch); ctcm_irq_handler()
1282 fsm_event(ch->fsm, CTC_EVENT_BUSY, ch); ctcm_irq_handler()
1286 fsm_event(ch->fsm, CTC_EVENT_ATTN, ch); ctcm_irq_handler()
1293 fsm_event(ch->fsm, CTC_EVENT_FINSTAT, ch); ctcm_irq_handler()
1295 fsm_event(ch->fsm, CTC_EVENT_IRQ, ch); ctcm_irq_handler()
1448 ch->fsm = init_fsm(ch->id, ctc_ch_state_names, add_channel()
1453 ch->fsm = init_fsm(ch->id, ctc_ch_state_names, add_channel()
1458 if (ch->fsm == NULL) add_channel()
1461 fsm_newstate(ch->fsm, CTC_STATE_IDLE); add_channel()
1480 fsm_settimer(ch->fsm, &ch->timer); add_channel()
1485 fsm_settimer(ch->fsm, &ch->sweep_timer); add_channel()
1498 kfree_fsm(ch->fsm); add_channel()
1612 strlcpy(priv->fsm->name, dev->name, sizeof(priv->fsm->name)); ctcm_new_device()
1675 if (priv->fsm) ctcm_shutdown_device()
1676 kfree_fsm(priv->fsm); ctcm_shutdown_device()
1715 if (!wait_event_timeout(priv->fsm->wait_q, ctcm_pm_suspend()
1716 fsm_getstate(priv->fsm) == DEV_STATE_STOPPED, CTCM_TIME_5_SEC)) { ctcm_pm_suspend()
H A Dctcm_fsms.c44 #include "fsm.h"
179 static void ctcmpc_chx_attn(fsm_instance *fsm, int event, void *arg);
182 static void ctcmpc_chx_send_sweep(fsm_instance *fsm, int event, void *arg);
199 fsm_event(ch->fsm, CTC_EVENT_IO_EBUSY, ch); ctcm_ccw_check_rc()
204 fsm_event(ch->fsm, CTC_EVENT_IO_ENODEV, ch); ctcm_ccw_check_rc()
209 fsm_event(ch->fsm, CTC_EVENT_IO_UNKNOWN, ch); ctcm_ccw_check_rc()
344 fsm_event(priv->fsm, DEV_EVENT_TXUP, ch->netdev); ctcm_chx_txidle()
462 fsm_event(priv->fsm, DEV_EVENT_TXUP, dev); chx_firstio()
498 fsm_event(priv->fsm, DEV_EVENT_RXUP, dev); chx_firstio()
535 fsm_event(priv->fsm, DEV_EVENT_RXUP, dev); chx_rxidle()
722 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev); ctcm_chx_cleanup()
731 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_cleanup()
817 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev); ctcm_chx_setuperr()
820 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_setuperr()
887 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev); ctcm_chx_rxiniterr()
918 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev); ctcm_chx_rxinitfail()
942 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev); ctcm_chx_rxdisc()
943 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_rxdisc()
947 fsm_newstate(ch2->fsm, CTC_STATE_DTERM); ctcm_chx_rxdisc()
972 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_txiniterr()
1008 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_txretry()
1009 /* call restart if not MPC or if MPC and mpcg fsm is ready. ctcm_chx_txretry()
1011 if (!(gptr && (fsm_getstate(gptr->fsm) != MPCG_STATE_READY))) ctcm_chx_txretry()
1029 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_txretry()
1083 fsm_event(priv->fsm, DEV_EVENT_RXDOWN, dev); ctcm_chx_iofatal()
1086 fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev); ctcm_chx_iofatal()
1314 fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev); ctcmpc_chx_txdone()
1350 fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev); ctcmpc_chx_txdone()
1424 fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev); ctcmpc_chx_rx()
1427 switch (fsm_getstate(grp->fsm)) { ctcmpc_chx_rx()
1448 switch (fsm_getstate(grp->fsm)) { ctcmpc_chx_rx()
1501 fsm_getstate(gptr->fsm), ch->protocol); ctcmpc_chx_firstio()
1517 fsm_event(priv->fsm, DEV_EVENT_TXUP, dev); ctcmpc_chx_firstio()
1554 fsm_getstate(fi), fsm_getstate(grp->fsm)); ctcmpc_chx_rxidle()
1559 switch (fsm_getstate(grp->fsm)) { ctcmpc_chx_rxidle()
1587 fsm_event(priv->fsm, DEV_EVENT_RXUP, dev); ctcmpc_chx_rxidle()
1597 static void ctcmpc_chx_attn(fsm_instance *fsm, int event, void *arg) ctcmpc_chx_attn() argument
1606 fsm_getstate_str(ch->fsm), fsm_getstate_str(grp->fsm)); ctcmpc_chx_attn()
1608 switch (fsm_getstate(grp->fsm)) { ctcmpc_chx_attn()
1613 if (fsm_getstate(ch->fsm) == CH_XID0_PENDING) { ctcmpc_chx_attn()
1618 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, ch); ctcmpc_chx_attn()
1620 } else if (fsm_getstate(ch->fsm) < CH_XID7_PENDING1) ctcmpc_chx_attn()
1622 fsm_newstate(ch->fsm, CH_XID7_PENDING1); ctcmpc_chx_attn()
1629 if (fsm_getstate(ch->fsm) < CH_XID7_PENDING1) ctcmpc_chx_attn()
1630 fsm_newstate(ch->fsm, CH_XID7_PENDING1); ctcmpc_chx_attn()
1636 switch (fsm_getstate(ch->fsm)) { ctcmpc_chx_attn()
1638 fsm_newstate(ch->fsm, CH_XID7_PENDING1); ctcmpc_chx_attn()
1641 fsm_newstate(ch->fsm, CH_XID7_PENDING3); ctcmpc_chx_attn()
1644 fsm_event(grp->fsm, MPCG_EVENT_XID7DONE, dev); ctcmpc_chx_attn()
1656 static void ctcmpc_chx_attnbusy(fsm_instance *fsm, int event, void *arg) ctcmpc_chx_attnbusy() argument
1665 fsm_getstate_str(ch->fsm), fsm_getstate_str(grp->fsm)); ctcmpc_chx_attnbusy()
1669 switch (fsm_getstate(grp->fsm)) { ctcmpc_chx_attnbusy()
1675 fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW); ctcmpc_chx_attnbusy()
1692 if (fsm_getstate(ch->fsm) == CH_XID0_INPROGRESS) { ctcmpc_chx_attnbusy()
1693 fsm_newstate(ch->fsm, CH_XID0_PENDING) ; ctcmpc_chx_attnbusy()
1697 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_chx_attnbusy()
1716 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_chx_attnbusy()
1726 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, ch); ctcmpc_chx_attnbusy()
1741 static void ctcmpc_chx_resend(fsm_instance *fsm, int event, void *arg) ctcmpc_chx_resend() argument
1748 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, ch); ctcmpc_chx_resend()
1757 static void ctcmpc_chx_send_sweep(fsm_instance *fsm, int event, void *arg) ctcmpc_chx_send_sweep() argument
1781 if (fsm_getstate(wch->fsm) != CTC_STATE_TXIDLE) { ctcmpc_chx_send_sweep()
1796 fsm_event(grp->fsm, MPCG_EVENT_INOP, dev); ctcmpc_chx_send_sweep()
1823 fsm_newstate(wch->fsm, CTC_STATE_TX); ctcmpc_chx_send_sweep()
2082 fsm_event(ch->fsm, CTC_EVENT_START, ch); dev_action_start()
2104 fsm_event(ch->fsm, CTC_EVENT_STOP, ch); dev_action_stop()
2110 fsm_newstate(priv->mpcg->fsm, MPCG_STATE_RESET); dev_action_stop()
2129 fsm_event(priv->fsm, DEV_EVENT_STOP, dev); dev_action_restart()
2131 fsm_newstate(priv->mpcg->fsm, MPCG_STATE_RESET); dev_action_restart()
H A Dfsm.h48 } fsm; typedef in typeref:struct:__anon8993
64 fsm *f;
150 printk(KERN_ERR "fsm(%s): Invalid state st(%ld/%ld) ev(%d/%ld)\n", fsm_event()
161 printk(KERN_DEBUG "fsm(%s): state %s event %s\n", fsm_event()
172 printk(KERN_DEBUG "fsm(%s): no function for event %s in state %s\n", fsm_event()
198 printk(KERN_DEBUG "fsm(%s): New state %s\n", fi->name, fsm_newstate()
H A Dnetiucv.c69 #include "fsm.h"
199 fsm_instance *fsm; member in struct:iucv_connection
227 fsm_instance *fsm; member in struct:netiucv_priv
537 fsm_event(conn->fsm, CONN_EVENT_RX, &ev); netiucv_callback_rx()
548 fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev); netiucv_callback_txdone()
555 fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, conn); netiucv_callback_connack()
580 fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev); netiucv_callback_connreq()
593 fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, conn); netiucv_callback_connrej()
600 fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, conn); netiucv_callback_connsusp()
607 fsm_event(conn->fsm, CONN_EVENT_CONN_RES, conn); netiucv_callback_connres()
832 fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev); conn_action_connaccept()
854 fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev); conn_action_connack()
882 fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev); conn_action_connsever()
987 fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev); conn_action_stop()
1054 fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn); dev_action_start()
1076 fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev); dev_action_stop()
1171 if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) { netiucv_transmit_skb()
1218 fsm_newstate(conn->fsm, CONN_STATE_TX); netiucv_transmit_skb()
1232 fsm_newstate(conn->fsm, CONN_STATE_IDLE); netiucv_transmit_skb()
1275 fsm_event(priv->fsm, DEV_EVENT_START, dev); netiucv_open()
1291 fsm_event(priv->fsm, DEV_EVENT_STOP, dev); netiucv_close()
1325 priv->pm_state = fsm_getstate(priv->fsm); netiucv_pm_freeze()
1398 if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) { netiucv_tx()
1617 return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm)); dev_fsm_show()
1628 return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm)); conn_fsm_show()
1903 conn->fsm = init_fsm("netiucvconn", conn_state_names, netiucv_new_connection()
1907 if (!conn->fsm) netiucv_new_connection()
1910 fsm_settimer(conn->fsm, &conn->timer); netiucv_new_connection()
1911 fsm_newstate(conn->fsm, CONN_STATE_INVALID); netiucv_new_connection()
1917 fsm_newstate(conn->fsm, CONN_STATE_STOPPED); netiucv_new_connection()
1954 kfree_fsm(conn->fsm); netiucv_remove_connection()
1974 if (privptr->fsm) netiucv_free_netdevice()
1975 kfree_fsm(privptr->fsm); netiucv_free_netdevice()
1976 privptr->conn = NULL; privptr->fsm = NULL; netiucv_free_netdevice()
2022 privptr->fsm = init_fsm("netiucvdev", dev_state_names, netiucv_init_netdevice()
2025 if (!privptr->fsm) netiucv_init_netdevice()
2033 fsm_newstate(privptr->fsm, DEV_STATE_STOPPED); netiucv_init_netdevice()
2037 kfree_fsm(privptr->fsm); netiucv_init_netdevice()
H A Dctcm_mpc.h15 #include "fsm.h"
198 fsm_instance *fsm; /* group xid fsm */ member in struct:mpc_group
H A Dctcm_sysfs.c88 fsm_getstate_str(priv->fsm)); ctcm_print_statistics()
90 fsm_getstate_str(priv->channel[CTCM_READ]->fsm)); ctcm_print_statistics()
92 fsm_getstate_str(priv->channel[CTCM_WRITE]->fsm)); ctcm_print_statistics()
H A Dctcm_main.h16 #include "fsm.h"
193 fsm_instance *fsm; /* finite state machine of this channel */ member in struct:channel
210 fsm_instance *fsm; member in struct:ctcm_priv
H A Dctcm_fsms.h39 #include "fsm.h"
248 * The (state/event/action) fsm table of the device interface statemachine.
/linux-4.4.14/drivers/net/ethernet/brocade/bna/
H A Dbfa_cs.h40 typedef void (*bfa_fsm_t)(void *fsm, int event);
48 static void oc ## _sm_ ## st(otype * fsm, etype event); \
49 static void oc ## _sm_ ## st ## _entry(otype * fsm)
52 (_fsm)->fsm = (bfa_fsm_t)(_state); \
56 #define bfa_fsm_send_event(_fsm, _event) ((_fsm)->fsm((_fsm), (_event)))
58 ((_fsm)->fsm == (bfa_fsm_t)(_state))
H A Dbfa_msgq.h67 bfa_fsm_t fsm; member in struct:bfa_msgq_cmdq
93 bfa_fsm_t fsm; member in struct:bfa_msgq_rspq
H A Dbna_types.h324 bfa_fsm_t fsm; member in struct:bna_ioceth
346 bfa_fsm_t fsm; member in struct:bna_enet
372 bfa_fsm_t fsm; member in struct:bna_ethport
471 bfa_fsm_t fsm; member in struct:bna_tx
710 bfa_fsm_t fsm; member in struct:bna_rxf
786 bfa_fsm_t fsm; member in struct:bna_rx
H A Dbfa_ioc.h159 bfa_fsm_t fsm; member in struct:bfa_iocpf
167 bfa_fsm_t fsm; member in struct:bfa_ioc
H A Dbna_enet.c1268 if (enet->fsm != (bfa_sm_t)bna_enet_sm_stopped) bna_enet_enable()
1762 if (ioceth->fsm == (bfa_fsm_t)bna_ioceth_sm_ready) { bna_ioceth_enable()
1767 if (ioceth->fsm == (bfa_fsm_t)bna_ioceth_sm_stopped) bna_ioceth_enable()
H A Dbna_tx_rx.c1967 if (rx->fsm == (bfa_fsm_t) bna_rx_sm_stopped) bna_rx_stop()
2546 if (rx->fsm != (bfa_sm_t)bna_rx_sm_stopped) bna_rx_enable()
3534 if (tx->fsm != (bfa_sm_t)bna_tx_sm_stopped) bna_tx_enable()
H A Dbfa_ioc.c2865 enum bfa_ioc_state ioc_st = bfa_sm_to_state(ioc_sm_table, ioc->fsm); bfa_ioc_get_state()
2870 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm); bfa_ioc_get_state()
2988 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm); bfa_nw_iocpf_timeout()
H A Dbnad.c1107 * Free all TxQs buffers and then notify TX_E_CLEANUP_DONE to Tx fsm.
1186 * Free all RxQs buffers and then notify RX_E_CLEANUP_DONE to Rx fsm.
/linux-4.4.14/drivers/net/irda/
H A Dsir_dev.c32 /* substate handler of the config-fsm to handle the cases where we want
38 struct sir_fsm *fsm = &dev->fsm; sirdev_tx_complete_fsm() local
43 next_state = fsm->substate; /* default: stay in current substate */ sirdev_tx_complete_fsm()
46 switch(fsm->substate) { sirdev_tx_complete_fsm()
88 fsm->substate = next_state; sirdev_tx_complete_fsm()
100 * On entry, fsm->sem is always locked and the netdev xmit queue stopped.
106 struct sir_dev *dev = container_of(work, struct sir_dev, fsm.work.work); sirdev_config_fsm()
107 struct sir_fsm *fsm = &dev->fsm; sirdev_config_fsm() local
116 __func__, fsm->state, fsm->substate); sirdev_config_fsm()
118 next_state = fsm->state; sirdev_config_fsm()
121 switch(fsm->state) { sirdev_config_fsm()
127 fsm->result = -EINVAL; sirdev_config_fsm()
134 ret = sirdev_get_dongle(dev, fsm->param); sirdev_config_fsm()
136 fsm->result = ret; sirdev_config_fsm()
148 fsm->substate = SIRDEV_STATE_DONGLE_RESET; sirdev_config_fsm()
151 fsm->param = 9600; sirdev_config_fsm()
158 fsm->result = -EINVAL; sirdev_config_fsm()
165 fsm->result = ret; sirdev_config_fsm()
174 (fsm->param&0x02) ? TRUE : FALSE, sirdev_config_fsm()
175 (fsm->param&0x01) ? TRUE : FALSE); sirdev_config_fsm()
180 fsm->substate = SIRDEV_STATE_WAIT_XMIT; sirdev_config_fsm()
187 fsm->result = ret; sirdev_config_fsm()
195 fsm->substate = SIRDEV_STATE_DONGLE_RESET; sirdev_config_fsm()
199 dev->speed = fsm->param; sirdev_config_fsm()
208 fsm->result = ret; sirdev_config_fsm()
219 fsm->substate = SIRDEV_STATE_DONGLE_SPEED; sirdev_config_fsm()
226 ret = dev->dongle_drv->set_speed(dev, fsm->param); sirdev_config_fsm()
228 fsm->result = ret; sirdev_config_fsm()
255 fsm->result = -EINVAL; sirdev_config_fsm()
260 __func__, fsm->result); sirdev_config_fsm()
272 up(&fsm->sem); sirdev_config_fsm()
275 fsm->state = next_state; sirdev_config_fsm()
278 queue_delayed_work(irda_sir_wq, &fsm->work, msecs_to_jiffies(delay)); sirdev_config_fsm()
288 struct sir_fsm *fsm = &dev->fsm; sirdev_schedule_request() local
293 if (down_trylock(&fsm->sem)) { sirdev_schedule_request()
298 down(&fsm->sem); sirdev_schedule_request()
301 if (fsm->state == SIRDEV_STATE_DEAD) { sirdev_schedule_request()
304 up(&fsm->sem); sirdev_schedule_request()
311 fsm->state = initial_state; sirdev_schedule_request()
312 fsm->param = param; sirdev_schedule_request()
313 fsm->result = 0; sirdev_schedule_request()
315 INIT_DELAYED_WORK(&fsm->work, sirdev_config_fsm); sirdev_schedule_request()
316 queue_delayed_work(irda_sir_wq, &fsm->work, 0); sirdev_schedule_request()
353 down(&dev->fsm.sem); /* block until config change completed */ sirdev_set_dongle()
354 err = dev->fsm.result; sirdev_set_dongle()
355 up(&dev->fsm.sem); sirdev_set_dongle()
608 /* Failed to initiate the speed change, likely the fsm sirdev_hard_xmit()
612 * fsm completes and wakes the queue. sirdev_hard_xmit()
844 down(&dev->fsm.sem); /* block on pending config completion */ sirdev_close()
865 up(&dev->fsm.sem); sirdev_close()
913 sema_init(&dev->fsm.sem, 1); sirdev_get_instance()
954 down(&dev->fsm.sem); sirdev_put_instance()
955 dev->fsm.state = SIRDEV_STATE_DEAD; /* mark staled */ sirdev_put_instance()
958 up(&dev->fsm.sem); sirdev_put_instance()
H A Dgirbil-sir.c120 unsigned state = dev->fsm.substate; girbil_change_speed()
181 dev->fsm.substate = state; girbil_change_speed()
202 unsigned state = dev->fsm.substate; girbil_reset()
242 dev->fsm.substate = state; girbil_reset()
H A Dmcp2120-sir.c96 unsigned state = dev->fsm.substate; mcp2120_change_speed()
157 dev->fsm.substate = state; mcp2120_change_speed()
181 unsigned state = dev->fsm.substate; mcp2120_reset()
214 dev->fsm.substate = state; mcp2120_reset()
H A Dtekram-sir.c124 unsigned state = dev->fsm.substate; tekram_change_speed()
182 dev->fsm.substate = state; tekram_change_speed()
H A Dact200l-sir.c194 unsigned state = dev->fsm.substate; act200l_reset()
240 dev->fsm.substate = state; act200l_reset()
H A Dsir-dev.h171 struct sir_fsm fsm; member in struct:sir_dev
H A Dtoim3232-sir.c236 unsigned state = dev->fsm.substate; toim3232_change_speed()
302 dev->fsm.substate = state; toim3232_change_speed()
/linux-4.4.14/lib/
H A Dts_fsm.c140 struct ts_fsm *fsm = ts_config_priv(conf); fsm_find() local
164 strict = fsm->tokens[0].recur != TS_FSM_HEAD_IGNORE; fsm_find()
169 for (tok_idx = 0; tok_idx < fsm->ntokens; tok_idx++) { fsm_find()
170 cur = &fsm->tokens[tok_idx]; fsm_find()
172 if (likely(tok_idx < (fsm->ntokens - 1))) fsm_find()
173 next = &fsm->tokens[tok_idx + 1]; fsm_find()
264 struct ts_fsm *fsm; fsm_init() local
267 size_t priv_size = sizeof(*fsm) + len; fsm_init()
291 fsm = ts_config_priv(conf); fsm_init()
292 fsm->ntokens = ntokens; fsm_init()
293 memcpy(fsm->tokens, pattern, len); fsm_init()
295 for (i = 0; i < fsm->ntokens; i++) { fsm_init()
296 struct ts_fsm_token *t = &fsm->tokens[i]; fsm_init()
308 struct ts_fsm *fsm = ts_config_priv(conf); fsm_get_pattern() local
309 return fsm->tokens; fsm_get_pattern()
314 struct ts_fsm *fsm = ts_config_priv(conf); fsm_get_pattern_len() local
315 return fsm->ntokens * sizeof(struct ts_fsm_token); fsm_get_pattern_len()
319 .name = "fsm",
/linux-4.4.14/drivers/scsi/bfa/
H A Dbfa_cs.h228 static void oc ## _sm_ ## st(otype * fsm, etype event)
248 typedef void (*bfa_fsm_t)(void *fsm, int event);
257 static void oc ## _sm_ ## st(otype * fsm, etype event); \
258 static void oc ## _sm_ ## st ## _entry(otype * fsm)
261 (_fsm)->fsm = (bfa_fsm_t)(_state); \
265 #define bfa_fsm_send_event(_fsm, _event) ((_fsm)->fsm((_fsm), (_event)))
266 #define bfa_fsm_get_state(_fsm) ((_fsm)->fsm)
268 ((_fsm)->fsm == (bfa_fsm_t)(_state))
H A Dbfa.h228 bfa_fsm_t fsm; member in struct:bfa_iocfc_s
H A Dbfa_ioc.h289 bfa_fsm_t fsm; member in struct:bfa_iocpf_s
297 bfa_fsm_t fsm; member in struct:bfa_ioc_s
H A Dbfa_ioc.c2832 enum bfa_ioc_state ioc_st = bfa_sm_to_state(ioc_sm_table, ioc->fsm); bfa_ioc_get_state()
2837 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm); bfa_ioc_get_state()
/linux-4.4.14/drivers/staging/gdm72xx/
H A Dgdm_wimax.c331 /* Indicate updating fsm */ gdm_wimax_ind_if_updown()
342 struct fsm_s *fsm = nic->sdk_data[SIOC_DATA_FSM].buf; gdm_wimax_open() local
346 if (fsm && fsm->m_status != M_INIT) gdm_wimax_open()
354 struct fsm_s *fsm = nic->sdk_data[SIOC_DATA_FSM].buf; gdm_wimax_close() local
358 if (fsm && fsm->m_status != M_INIT) gdm_wimax_close()
421 static void gdm_wimax_ind_fsm_update(struct net_device *dev, struct fsm_s *fsm) gdm_wimax_ind_fsm_update() argument
426 /* Indicate updating fsm */ gdm_wimax_ind_fsm_update()
429 memcpy(&hci->data[0], fsm, sizeof(struct fsm_s)); gdm_wimax_ind_fsm_update()
801 struct fsm_s *fsm = nic->sdk_data[SIOC_DATA_FSM].buf; unregister_wimax_device() local
803 if (fsm) unregister_wimax_device()
804 fsm->m_status = M_INIT; unregister_wimax_device()
/linux-4.4.14/arch/cris/include/arch-v32/arch/hwregs/iop/
H A Diop_spu_defs.h111 unsigned int fsm : 1; member in struct:__anon599
334 unsigned int fsm : 1; member in struct:__anon609
348 unsigned int fsm : 1; member in struct:__anon610
369 unsigned int fsm : 1; member in struct:__anon611
/linux-4.4.14/drivers/input/touchscreen/
H A Dti_am335x_tsc.c269 unsigned int fsm, status, irqclr = 0; titsc_irq() local
282 fsm = titsc_readl(ts_dev, REG_ADCFSM); titsc_irq()
283 if (fsm == ADCFSM_STEPID) { titsc_irq()
/linux-4.4.14/arch/cris/arch-v32/drivers/
H A Diop_fw_load.c61 .fsm = regk_iop_spu_no, iop_fw_load_spu()
/linux-4.4.14/drivers/isdn/pcbit/
H A Dedss1.c282 printk(KERN_DEBUG "fsm error: event %x on state %x\n", pcbit_fsm_event()
/linux-4.4.14/drivers/net/wireless/ath/ath9k/
H A Dhtc.h409 } updateslot; /* slot time update fsm */
H A Dath9k.h671 } updateslot; /* slot time update fsm */
/linux-4.4.14/net/tipc/
H A Dnode.c827 pr_err("Unknown node fsm state %x\n", state); tipc_node_fsm_evt()
834 pr_err("Illegal node fsm evt %x in state %x\n", evt, state); tipc_node_fsm_evt()
/linux-4.4.14/arch/powerpc/xmon/
H A Dspu-insns.h140 APUOP(M_FSMBI, RI16, 0x194, "fsmbi", _A2(A_T,A_X16), 00002, SHUF) /* FormSelMask%I RT<-fsm(I16) */
171 APUOP(M_FSM, RR, 0x1b4, "fsm", _A2(A_T,A_A), 00012, SHUF) /* FormSelMask% RT<-expand(Ra) */
/linux-4.4.14/drivers/power/
H A D88pm860x_charger.c109 unsigned state:3; /* fsm state */
/linux-4.4.14/drivers/block/
H A Dxsysace.c779 "kicking stalled fsm; state=%i task=%i iter=%i dc=%i\n", ace_stall_timer()
/linux-4.4.14/drivers/net/wireless/b43/
H A Dphy_lp.h187 #define B43_LPPHY_PKT_FSM_RESET_LEN_VAL B43_PHY_OFDM(0x62) /* Pkt fsm Reset Len Value */
/linux-4.4.14/drivers/infiniband/hw/mlx4/
H A Dqp.c1804 context->pri_path.feup = 1 << 7; /* don't fsm */ __mlx4_ib_modify_qp()
/linux-4.4.14/drivers/net/ethernet/broadcom/bnx2x/
H A Dbnx2x_link.c5504 /* The combined cl37/cl73 fsm state information indicating that bnx2x_check_fallback_to_cl37()

Completed in 4823 milliseconds