| /linux-4.1.27/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/ |
| H A D | SchedGui.py | 23 def __init__(self, sched_tracer, title, parent = None, id = -1):
24 wx.Frame.__init__(self, parent, id, title)
26 (self.screen_width, self.screen_height) = wx.GetDisplaySize()
27 self.screen_width -= 10
28 self.screen_height -= 10
29 self.zoom = 0.5
30 self.scroll_scale = 20
31 self.sched_tracer = sched_tracer
32 self.sched_tracer.set_root_win(self)
33 (self.ts_start, self.ts_end) = sched_tracer.interval()
34 self.update_width_virtual()
35 self.nr_rects = sched_tracer.nr_rectangles() + 1
36 self.height_virtual = RootFrame.Y_OFFSET + (self.nr_rects * (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE))
39 self.panel = wx.Panel(self, size=(self.screen_width, self.screen_height))
42 self.scroll = wx.ScrolledWindow(self.panel)
43 self.scroll.SetScrollbars(self.scroll_scale, self.scroll_scale, self.width_virtual / self.scroll_scale, self.height_virtual / self.scroll_scale)
44 self.scroll.EnableScrolling(True, True)
45 self.scroll.SetFocus()
48 self.scroll_panel = wx.Panel(self.scroll, size=(self.screen_width - 15, self.screen_height / 2))
49 self.scroll_panel.Bind(wx.EVT_PAINT, self.on_paint)
50 self.scroll_panel.Bind(wx.EVT_KEY_DOWN, self.on_key_press)
51 self.scroll_panel.Bind(wx.EVT_LEFT_DOWN, self.on_mouse_down)
52 self.scroll.Bind(wx.EVT_PAINT, self.on_paint)
53 self.scroll.Bind(wx.EVT_KEY_DOWN, self.on_key_press)
54 self.scroll.Bind(wx.EVT_LEFT_DOWN, self.on_mouse_down)
56 self.scroll.Fit()
57 self.Fit()
59 self.scroll_panel.SetDimensions(-1, -1, self.width_virtual, self.height_virtual, wx.SIZE_USE_EXISTING)
61 self.txt = None
63 self.Show(True)
65 def us_to_px(self, val):
66 return val / (10 ** 3) * self.zoom
68 def px_to_us(self, val):
69 return (val / self.zoom) * (10 ** 3)
71 def scroll_start(self):
72 (x, y) = self.scroll.GetViewStart()
73 return (x * self.scroll_scale, y * self.scroll_scale)
75 def scroll_start_us(self):
76 (x, y) = self.scroll_start()
77 return self.px_to_us(x)
79 def paint_rectangle_zone(self, nr, color, top_color, start, end):
80 offset_px = self.us_to_px(start - self.ts_start)
81 width_px = self.us_to_px(end - self.ts_start)
86 dc = self.dc
103 def update_rectangles(self, dc, start, end):
104 start += self.ts_start
105 end += self.ts_start
106 self.sched_tracer.fill_zone(start, end)
108 def on_paint(self, event):
109 dc = wx.PaintDC(self.scroll_panel)
110 self.dc = dc
112 width = min(self.width_virtual, self.screen_width)
113 (x, y) = self.scroll_start()
114 start = self.px_to_us(x)
115 end = self.px_to_us(x + width)
116 self.update_rectangles(dc, start, end)
118 def rect_from_ypixel(self, y):
123 if rect < 0 or rect > self.nr_rects - 1 or height > RootFrame.RECT_HEIGHT:
128 def update_summary(self, txt):
129 if self.txt:
130 self.txt.Destroy()
131 self.txt = wx.StaticText(self.panel, -1, txt, (0, (self.screen_height / 2) + 50))
134 def on_mouse_down(self, event):
136 rect = self.rect_from_ypixel(y)
140 t = self.px_to_us(x) + self.ts_start
142 self.sched_tracer.mouse_down(rect, t)
145 def update_width_virtual(self):
146 self.width_virtual = self.us_to_px(self.ts_end - self.ts_start)
148 def __zoom(self, x):
149 self.update_width_virtual()
150 (xpos, ypos) = self.scroll.GetViewStart()
151 xpos = self.us_to_px(x) / self.scroll_scale
152 self.scroll.SetScrollbars(self.scroll_scale, self.scroll_scale, self.width_virtual / self.scroll_scale, self.height_virtual / self.scroll_scale, xpos, ypos)
153 self.Refresh()
155 def zoom_in(self):
156 x = self.scroll_start_us()
157 self.zoom *= 2
158 self.__zoom(x)
160 def zoom_out(self):
161 x = self.scroll_start_us()
162 self.zoom /= 2
163 self.__zoom(x)
166 def on_key_press(self, event):
169 self.zoom_in()
172 self.zoom_out()
176 (x, y) = self.scroll.GetViewStart()
178 self.scroll.Scroll(x + 1, y)
180 self.scroll.Scroll(x - 1, y)
182 self.scroll.Scroll(x, y + 1)
184 self.scroll.Scroll(x, y - 1)
|
| H A D | EventClass.py | 36 def __init__(self, name, comm, dso, symbol, raw_buf, ev_type=EVTYPE_GENERIC):
37 self.name = name
38 self.comm = comm
39 self.dso = dso
40 self.symbol = symbol
41 self.raw_buf = raw_buf
42 self.ev_type = ev_type
45 def show(self):
46 print "PMU event: name=%12s, symbol=%24s, comm=%8s, dso=%12s" % (self.name, self.symbol, self.comm, self.dso)
55 def __init__(self, name, comm, dso, symbol, raw_buf, ev_type=EVTYPE_PEBS):
58 self.flags = flags
59 self.ip = ip
60 self.ax = ax
61 self.bx = bx
62 self.cx = cx
63 self.dx = dx
64 self.si = si
65 self.di = di
66 self.bp = bp
67 self.sp = sp
69 PerfEvent.__init__(self, name, comm, dso, symbol, raw_buf, ev_type)
84 def __init__(self, name, comm, dso, symbol, raw_buf, ev_type=EVTYPE_PEBS_LL):
87 self.status = status
88 self.dla = dla
89 self.dse = dse
90 self.lat = lat
92 PebsEvent.__init__(self, name, comm, dso, symbol, raw_buf, ev_type)
|
| H A D | Core.py | 109 def __init__(self, common_cpu, common_secs, common_nsecs,
111 self.cpu = common_cpu
112 self.secs = common_secs
113 self.nsecs = common_nsecs
114 self.pid = common_pid
115 self.comm = common_comm
116 self.callchain = common_callchain
118 def ts(self):
119 return (self.secs * (10 ** 9)) + self.nsecs
121 def ts_format(self):
122 return "%d.%d" % (self.secs, int(self.nsecs / 1000))
|
| /linux-4.1.27/net/irda/ircomm/ |
| H A D | ircomm_tty_attach.c | 47 static void ircomm_tty_ias_register(struct ircomm_tty_cb *self);
53 static void ircomm_tty_start_watchdog_timer(struct ircomm_tty_cb *self,
57 static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
61 static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
65 static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
69 static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
73 static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
77 static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
109 static int (*state[])(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event,
127 int ircomm_tty_attach_cable(struct ircomm_tty_cb *self) ircomm_tty_attach_cable() argument
131 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_attach_cable()
132 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_attach_cable()
135 if (ircomm_is_connected(self->ircomm)) { ircomm_tty_attach_cable()
141 tty = tty_port_tty_get(&self->port); ircomm_tty_attach_cable()
147 ircomm_tty_ias_register(self); ircomm_tty_attach_cable()
149 ircomm_tty_do_event(self, IRCOMM_TTY_ATTACH_CABLE, NULL, NULL); ircomm_tty_attach_cable()
160 void ircomm_tty_detach_cable(struct ircomm_tty_cb *self) ircomm_tty_detach_cable() argument
162 IRDA_ASSERT(self != NULL, return;); ircomm_tty_detach_cable()
163 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_detach_cable()
165 del_timer(&self->watchdog_timer); ircomm_tty_detach_cable()
168 if (self->ckey) { ircomm_tty_detach_cable()
169 irlmp_unregister_client(self->ckey); ircomm_tty_detach_cable()
170 self->ckey = NULL; ircomm_tty_detach_cable()
173 if (self->skey) { ircomm_tty_detach_cable()
174 irlmp_unregister_service(self->skey); ircomm_tty_detach_cable()
175 self->skey = NULL; ircomm_tty_detach_cable()
178 if (self->iriap) { ircomm_tty_detach_cable()
179 iriap_close(self->iriap); ircomm_tty_detach_cable()
180 self->iriap = NULL; ircomm_tty_detach_cable()
184 if (self->obj) { ircomm_tty_detach_cable()
185 irias_delete_object(self->obj); ircomm_tty_detach_cable()
186 self->obj = NULL; ircomm_tty_detach_cable()
189 ircomm_tty_do_event(self, IRCOMM_TTY_DETACH_CABLE, NULL, NULL); ircomm_tty_detach_cable()
192 self->daddr = self->saddr = 0; ircomm_tty_detach_cable()
193 self->dlsap_sel = self->slsap_sel = 0; ircomm_tty_detach_cable()
195 memset(&self->settings, 0, sizeof(struct ircomm_params)); ircomm_tty_detach_cable()
199 * Function ircomm_tty_ias_register (self)
204 static void ircomm_tty_ias_register(struct ircomm_tty_cb *self) ircomm_tty_ias_register() argument
209 IRDA_ASSERT(self != NULL, return;); ircomm_tty_ias_register()
210 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_ias_register()
214 if (self->service_type & IRCOMM_3_WIRE_RAW) ircomm_tty_ias_register()
218 if (!self->skey) ircomm_tty_ias_register()
219 self->skey = irlmp_register_service(hints); ircomm_tty_ias_register()
221 if (!self->ckey) ircomm_tty_ias_register()
222 self->ckey = irlmp_register_client(hints, ircomm_tty_ias_register()
224 NULL, (void *) self); ircomm_tty_ias_register()
227 if (self->obj) ircomm_tty_ias_register()
230 if (self->service_type & IRCOMM_3_WIRE_RAW) { ircomm_tty_ias_register()
232 self->obj = irias_new_object("IrLPT", IAS_IRLPT_ID); ircomm_tty_ias_register()
233 irias_add_integer_attrib(self->obj, "IrDA:IrLMP:LsapSel", ircomm_tty_ias_register()
234 self->slsap_sel, IAS_KERNEL_ATTR); ircomm_tty_ias_register()
237 self->obj = irias_new_object("IrDA:IrCOMM", IAS_IRCOMM_ID); ircomm_tty_ias_register()
238 irias_add_integer_attrib(self->obj, "IrDA:TinyTP:LsapSel", ircomm_tty_ias_register()
239 self->slsap_sel, IAS_KERNEL_ATTR); ircomm_tty_ias_register()
243 IRCOMM_SERVICE_TYPE, 1, self->service_type, ircomm_tty_ias_register()
247 irias_add_octseq_attrib(self->obj, "Parameters", oct_seq, 6, ircomm_tty_ias_register()
250 irias_insert_object(self->obj); ircomm_tty_ias_register()
254 * Function ircomm_tty_ias_unregister (self)
259 static void ircomm_tty_ias_unregister(struct ircomm_tty_cb *self) ircomm_tty_ias_unregister() argument
273 if (self->obj) { ircomm_tty_ias_unregister()
274 irias_delete_object(self->obj); ircomm_tty_ias_unregister()
275 self->obj = NULL; ircomm_tty_ias_unregister()
283 if (self->ckey) { ircomm_tty_ias_unregister()
284 irlmp_unregister_client(self->ckey); ircomm_tty_ias_unregister()
285 self->ckey = NULL; ircomm_tty_ias_unregister()
291 * Function ircomm_send_initial_parameters (self)
296 int ircomm_tty_send_initial_parameters(struct ircomm_tty_cb *self) ircomm_tty_send_initial_parameters() argument
298 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_send_initial_parameters()
299 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_send_initial_parameters()
301 if (self->service_type & IRCOMM_3_WIRE_RAW) ircomm_tty_send_initial_parameters()
309 self->settings.data_rate); ircomm_tty_send_initial_parameters()
310 if (!self->settings.data_rate) ircomm_tty_send_initial_parameters()
311 self->settings.data_rate = 9600; ircomm_tty_send_initial_parameters()
313 self->settings.data_format); ircomm_tty_send_initial_parameters()
314 if (!self->settings.data_format) ircomm_tty_send_initial_parameters()
315 self->settings.data_format = IRCOMM_WSIZE_8; /* 8N1 */ ircomm_tty_send_initial_parameters()
318 self->settings.flow_control); ircomm_tty_send_initial_parameters()
319 /*self->settings.flow_control = IRCOMM_RTS_CTS_IN|IRCOMM_RTS_CTS_OUT;*/ ircomm_tty_send_initial_parameters()
322 self->settings.dte = IRCOMM_DTR | IRCOMM_RTS; ircomm_tty_send_initial_parameters()
325 if (self->client) ircomm_tty_send_initial_parameters()
326 ircomm_param_request(self, IRCOMM_SERVICE_TYPE, FALSE); ircomm_tty_send_initial_parameters()
327 ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE); ircomm_tty_send_initial_parameters()
328 ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE); ircomm_tty_send_initial_parameters()
331 if (self->settings.service_type == IRCOMM_3_WIRE) { ircomm_tty_send_initial_parameters()
332 ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE); ircomm_tty_send_initial_parameters()
337 ircomm_param_request(self, IRCOMM_FLOW_CONTROL, FALSE); ircomm_tty_send_initial_parameters()
339 ircomm_param_request(self, IRCOMM_XON_XOFF, FALSE); ircomm_tty_send_initial_parameters()
340 ircomm_param_request(self, IRCOMM_ENQ_ACK, FALSE); ircomm_tty_send_initial_parameters()
343 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_tty_send_initial_parameters()
359 struct ircomm_tty_cb *self; ircomm_tty_discovery_indication() local
379 self = priv; ircomm_tty_discovery_indication()
380 ircomm_tty_do_event(self, IRCOMM_TTY_DISCOVERY_INDICATION, ircomm_tty_discovery_indication()
394 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_tty_disconnect_indication() local
397 IRDA_ASSERT(self != NULL, return;); ircomm_tty_disconnect_indication()
398 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_disconnect_indication()
400 tty = tty_port_tty_get(&self->port); ircomm_tty_disconnect_indication()
405 self->flow = FLOW_STOP; ircomm_tty_disconnect_indication()
410 ircomm_tty_do_event(self, IRCOMM_TTY_DISCONNECT_INDICATION, NULL, ircomm_tty_disconnect_indication()
425 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) priv; ircomm_tty_getvalue_confirm() local
427 IRDA_ASSERT(self != NULL, return;); ircomm_tty_getvalue_confirm()
428 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_getvalue_confirm()
431 iriap_close(self->iriap); ircomm_tty_getvalue_confirm()
432 self->iriap = NULL; ircomm_tty_getvalue_confirm()
444 irda_param_extract_all(self, value->t.oct_seq, value->len, ircomm_tty_getvalue_confirm()
447 ircomm_tty_do_event(self, IRCOMM_TTY_GOT_PARAMETERS, NULL, ircomm_tty_getvalue_confirm()
458 self->dlsap_sel = value->t.integer; ircomm_tty_getvalue_confirm()
460 ircomm_tty_do_event(self, IRCOMM_TTY_GOT_LSAPSEL, NULL, NULL); ircomm_tty_getvalue_confirm()
484 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_tty_connect_confirm() local
486 IRDA_ASSERT(self != NULL, return;); ircomm_tty_connect_confirm()
487 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_connect_confirm()
489 self->client = TRUE; ircomm_tty_connect_confirm()
490 self->max_data_size = max_data_size; ircomm_tty_connect_confirm()
491 self->max_header_size = max_header_size; ircomm_tty_connect_confirm()
492 self->flow = FLOW_START; ircomm_tty_connect_confirm()
494 ircomm_tty_do_event(self, IRCOMM_TTY_CONNECT_CONFIRM, NULL, NULL); ircomm_tty_connect_confirm()
512 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_tty_connect_indication() local
515 IRDA_ASSERT(self != NULL, return;); ircomm_tty_connect_indication()
516 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_connect_indication()
518 self->client = FALSE; ircomm_tty_connect_indication()
519 self->max_data_size = max_data_size; ircomm_tty_connect_indication()
520 self->max_header_size = max_header_size; ircomm_tty_connect_indication()
521 self->flow = FLOW_START; ircomm_tty_connect_indication()
525 irda_param_extract_all(self, skb->data+1, ircomm_tty_connect_indication()
529 ircomm_tty_do_event(self, IRCOMM_TTY_CONNECT_INDICATION, NULL, NULL); ircomm_tty_connect_indication()
535 * Function ircomm_tty_link_established (self)
540 void ircomm_tty_link_established(struct ircomm_tty_cb *self) ircomm_tty_link_established() argument
544 IRDA_ASSERT(self != NULL, return;); ircomm_tty_link_established()
545 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_link_established()
547 tty = tty_port_tty_get(&self->port); ircomm_tty_link_established()
551 del_timer(&self->watchdog_timer); ircomm_tty_link_established()
559 if (tty_port_cts_enabled(&self->port) && ircomm_tty_link_established()
560 ((self->settings.dce & IRCOMM_CTS) == 0)) { ircomm_tty_link_established()
569 wake_up_interruptible(&self->port.open_wait); ircomm_tty_link_established()
572 schedule_work(&self->tqueue); ircomm_tty_link_established()
578 * Function ircomm_tty_start_watchdog_timer (self, timeout)
584 static void ircomm_tty_start_watchdog_timer(struct ircomm_tty_cb *self, ircomm_tty_start_watchdog_timer() argument
587 IRDA_ASSERT(self != NULL, return;); ircomm_tty_start_watchdog_timer()
588 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_start_watchdog_timer()
590 irda_start_timer(&self->watchdog_timer, timeout, (void *) self, ircomm_tty_start_watchdog_timer()
602 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) data; ircomm_tty_watchdog_timer_expired() local
604 IRDA_ASSERT(self != NULL, return;); ircomm_tty_watchdog_timer_expired()
605 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_watchdog_timer_expired()
607 ircomm_tty_do_event(self, IRCOMM_TTY_WD_TIMER_EXPIRED, NULL, NULL); ircomm_tty_watchdog_timer_expired()
612 * Function ircomm_tty_do_event (self, event, skb)
617 int ircomm_tty_do_event(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event, ircomm_tty_do_event() argument
620 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_do_event()
621 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_do_event()
624 ircomm_tty_state[self->state], ircomm_tty_event[event]); ircomm_tty_do_event()
626 return (*state[self->state])(self, event, skb, info); ircomm_tty_do_event()
630 * Function ircomm_tty_next_state (self, state)
635 static inline void ircomm_tty_next_state(struct ircomm_tty_cb *self, IRCOMM_TTY_STATE state) ircomm_tty_next_state() argument
638 IRDA_ASSERT(self != NULL, return;); ircomm_tty_next_state()
639 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_next_state()
642 ircomm_tty_state[self->state], self->service_type); ircomm_tty_next_state()
644 self->state = state; ircomm_tty_next_state()
648 * Function ircomm_tty_state_idle (self, event, skb, info)
653 static int ircomm_tty_state_idle(struct ircomm_tty_cb *self, ircomm_tty_state_idle() argument
661 ircomm_tty_state[self->state], ircomm_tty_event[event]); ircomm_tty_state_idle()
665 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_idle()
666 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH); ircomm_tty_state_idle()
671 self->daddr = info->daddr; ircomm_tty_state_idle()
672 self->saddr = info->saddr; ircomm_tty_state_idle()
674 if (self->iriap) { ircomm_tty_state_idle()
680 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, ircomm_tty_state_idle()
683 iriap_getvaluebyclass_request(self->iriap, ircomm_tty_state_idle()
684 self->saddr, self->daddr, ircomm_tty_state_idle()
687 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_idle()
688 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_PARAMETERS); ircomm_tty_state_idle()
691 del_timer(&self->watchdog_timer); ircomm_tty_state_idle()
694 ircomm_connect_response(self->ircomm, NULL); ircomm_tty_state_idle()
695 ircomm_tty_next_state(self, IRCOMM_TTY_READY); ircomm_tty_state_idle()
701 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE); ircomm_tty_state_idle()
712 * Function ircomm_tty_state_search (self, event, skb, info)
717 static int ircomm_tty_state_search(struct ircomm_tty_cb *self, ircomm_tty_state_search() argument
725 ircomm_tty_state[self->state], ircomm_tty_event[event]); ircomm_tty_state_search()
729 self->daddr = info->daddr; ircomm_tty_state_search()
730 self->saddr = info->saddr; ircomm_tty_state_search()
732 if (self->iriap) { ircomm_tty_state_search()
738 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, ircomm_tty_state_search()
741 if (self->service_type == IRCOMM_3_WIRE_RAW) { ircomm_tty_state_search()
742 iriap_getvaluebyclass_request(self->iriap, self->saddr, ircomm_tty_state_search()
743 self->daddr, "IrLPT", ircomm_tty_state_search()
745 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_LSAP_SEL); ircomm_tty_state_search()
747 iriap_getvaluebyclass_request(self->iriap, self->saddr, ircomm_tty_state_search()
748 self->daddr, ircomm_tty_state_search()
752 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_PARAMETERS); ircomm_tty_state_search()
754 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_search()
757 del_timer(&self->watchdog_timer); ircomm_tty_state_search()
758 ircomm_tty_ias_unregister(self); ircomm_tty_state_search()
761 ircomm_connect_response(self->ircomm, NULL); ircomm_tty_state_search()
762 ircomm_tty_next_state(self, IRCOMM_TTY_READY); ircomm_tty_state_search()
769 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_search()
774 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE); ircomm_tty_state_search()
785 * Function ircomm_tty_state_query (self, event, skb, info)
790 static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self, ircomm_tty_state_query_parameters() argument
798 ircomm_tty_state[self->state], ircomm_tty_event[event]); ircomm_tty_state_query_parameters()
802 if (self->iriap) { ircomm_tty_state_query_parameters()
808 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, ircomm_tty_state_query_parameters()
811 iriap_getvaluebyclass_request(self->iriap, self->saddr, ircomm_tty_state_query_parameters()
812 self->daddr, "IrDA:IrCOMM", ircomm_tty_state_query_parameters()
815 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_query_parameters()
816 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_LSAP_SEL); ircomm_tty_state_query_parameters()
820 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH); ircomm_tty_state_query_parameters()
821 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_query_parameters()
824 del_timer(&self->watchdog_timer); ircomm_tty_state_query_parameters()
825 ircomm_tty_ias_unregister(self); ircomm_tty_state_query_parameters()
828 ircomm_connect_response(self->ircomm, NULL); ircomm_tty_state_query_parameters()
829 ircomm_tty_next_state(self, IRCOMM_TTY_READY); ircomm_tty_state_query_parameters()
832 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE); ircomm_tty_state_query_parameters()
843 * Function ircomm_tty_state_query_lsap_sel (self, event, skb, info)
848 static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self, ircomm_tty_state_query_lsap_sel() argument
856 ircomm_tty_state[self->state], ircomm_tty_event[event]); ircomm_tty_state_query_lsap_sel()
861 ret = ircomm_connect_request(self->ircomm, self->dlsap_sel, ircomm_tty_state_query_lsap_sel()
862 self->saddr, self->daddr, ircomm_tty_state_query_lsap_sel()
863 NULL, self->service_type); ircomm_tty_state_query_lsap_sel()
864 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_query_lsap_sel()
865 ircomm_tty_next_state(self, IRCOMM_TTY_SETUP); ircomm_tty_state_query_lsap_sel()
869 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH); ircomm_tty_state_query_lsap_sel()
870 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_query_lsap_sel()
873 del_timer(&self->watchdog_timer); ircomm_tty_state_query_lsap_sel()
874 ircomm_tty_ias_unregister(self); ircomm_tty_state_query_lsap_sel()
877 ircomm_connect_response(self->ircomm, NULL); ircomm_tty_state_query_lsap_sel()
878 ircomm_tty_next_state(self, IRCOMM_TTY_READY); ircomm_tty_state_query_lsap_sel()
881 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE); ircomm_tty_state_query_lsap_sel()
892 * Function ircomm_tty_state_setup (self, event, skb, info)
897 static int ircomm_tty_state_setup(struct ircomm_tty_cb *self, ircomm_tty_state_setup() argument
905 ircomm_tty_state[self->state], ircomm_tty_event[event]); ircomm_tty_state_setup()
909 del_timer(&self->watchdog_timer); ircomm_tty_state_setup()
910 ircomm_tty_ias_unregister(self); ircomm_tty_state_setup()
916 ircomm_tty_send_initial_parameters(self); ircomm_tty_state_setup()
917 ircomm_tty_link_established(self); ircomm_tty_state_setup()
918 ircomm_tty_next_state(self, IRCOMM_TTY_READY); ircomm_tty_state_setup()
921 del_timer(&self->watchdog_timer); ircomm_tty_state_setup()
922 ircomm_tty_ias_unregister(self); ircomm_tty_state_setup()
925 ircomm_connect_response(self->ircomm, NULL); ircomm_tty_state_setup()
926 ircomm_tty_next_state(self, IRCOMM_TTY_READY); ircomm_tty_state_setup()
930 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH); ircomm_tty_state_setup()
931 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_setup()
934 /* ircomm_disconnect_request(self->ircomm, NULL); */ ircomm_tty_state_setup()
935 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE); ircomm_tty_state_setup()
946 * Function ircomm_tty_state_ready (self, event, skb, info)
951 static int ircomm_tty_state_ready(struct ircomm_tty_cb *self, ircomm_tty_state_ready() argument
960 ret = ircomm_data_request(self->ircomm, skb); ircomm_tty_state_ready()
963 ircomm_disconnect_request(self->ircomm, NULL); ircomm_tty_state_ready()
964 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE); ircomm_tty_state_ready()
967 ircomm_tty_ias_register(self); ircomm_tty_state_ready()
968 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH); ircomm_tty_state_ready()
969 ircomm_tty_start_watchdog_timer(self, 3*HZ); ircomm_tty_state_ready()
971 if (self->port.flags & ASYNC_CHECK_CD) { ircomm_tty_state_ready()
973 self->settings.dce = IRCOMM_DELTA_CD; ircomm_tty_state_ready()
974 ircomm_tty_check_modem_status(self); ircomm_tty_state_ready()
977 tty_port_tty_hangup(&self->port, false); ircomm_tty_state_ready()
|
| H A D | ircomm_core.c | 49 static int __ircomm_close(struct ircomm_cb *self);
50 static void ircomm_control_indication(struct ircomm_cb *self,
109 struct ircomm_cb *self = NULL; ircomm_open() local
117 self = kzalloc(sizeof(struct ircomm_cb), GFP_KERNEL); ircomm_open()
118 if (self == NULL) ircomm_open()
121 self->notify = *notify; ircomm_open()
122 self->magic = IRCOMM_MAGIC; ircomm_open()
126 self->flow_status = FLOW_START; ircomm_open()
127 ret = ircomm_open_lsap(self); ircomm_open()
129 ret = ircomm_open_tsap(self); ircomm_open()
132 kfree(self); ircomm_open()
136 self->service_type = service_type; ircomm_open()
137 self->line = line; ircomm_open()
139 hashbin_insert(ircomm, (irda_queue_t *) self, line, NULL); ircomm_open()
141 ircomm_next_state(self, IRCOMM_IDLE); ircomm_open()
143 return self; ircomm_open()
149 * Function ircomm_close_instance (self)
154 static int __ircomm_close(struct ircomm_cb *self) __ircomm_close() argument
157 ircomm_do_event(self, IRCOMM_DISCONNECT_REQUEST, NULL, NULL); __ircomm_close()
160 if (self->tsap) { __ircomm_close()
161 irttp_close_tsap(self->tsap); __ircomm_close()
162 self->tsap = NULL; __ircomm_close()
166 if (self->lsap) { __ircomm_close()
167 irlmp_close_lsap(self->lsap); __ircomm_close()
168 self->lsap = NULL; __ircomm_close()
170 self->magic = 0; __ircomm_close()
172 kfree(self); __ircomm_close()
178 * Function ircomm_close (self)
183 int ircomm_close(struct ircomm_cb *self) ircomm_close() argument
187 IRDA_ASSERT(self != NULL, return -EIO;); ircomm_close()
188 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EIO;); ircomm_close()
190 entry = hashbin_remove(ircomm, self->line, NULL); ircomm_close()
192 IRDA_ASSERT(entry == self, return -1;); ircomm_close()
194 return __ircomm_close(self); ircomm_close()
200 * Function ircomm_connect_request (self, service_type)
206 int ircomm_connect_request(struct ircomm_cb *self, __u8 dlsap_sel, ircomm_connect_request() argument
213 IRDA_ASSERT(self != NULL, return -1;); ircomm_connect_request()
214 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;); ircomm_connect_request()
216 self->service_type= service_type; ircomm_connect_request()
222 ret = ircomm_do_event(self, IRCOMM_CONNECT_REQUEST, skb, &info); ircomm_connect_request()
230 * Function ircomm_connect_indication (self, qos, skb)
235 void ircomm_connect_indication(struct ircomm_cb *self, struct sk_buff *skb, ircomm_connect_indication() argument
243 if (self->notify.connect_indication) ircomm_connect_indication()
244 self->notify.connect_indication(self->notify.instance, self, ircomm_connect_indication()
253 * Function ircomm_connect_response (self, userdata, max_sdu_size)
258 int ircomm_connect_response(struct ircomm_cb *self, struct sk_buff *userdata) ircomm_connect_response() argument
262 IRDA_ASSERT(self != NULL, return -1;); ircomm_connect_response()
263 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;); ircomm_connect_response()
265 ret = ircomm_do_event(self, IRCOMM_CONNECT_RESPONSE, userdata, NULL); ircomm_connect_response()
273 * Function connect_confirm (self, skb)
278 void ircomm_connect_confirm(struct ircomm_cb *self, struct sk_buff *skb, ircomm_connect_confirm() argument
281 if (self->notify.connect_confirm ) ircomm_connect_confirm()
282 self->notify.connect_confirm(self->notify.instance, ircomm_connect_confirm()
283 self, info->qos, ircomm_connect_confirm()
292 * Function ircomm_data_request (self, userdata)
297 int ircomm_data_request(struct ircomm_cb *self, struct sk_buff *skb) ircomm_data_request() argument
301 IRDA_ASSERT(self != NULL, return -EFAULT;); ircomm_data_request()
302 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EFAULT;); ircomm_data_request()
305 ret = ircomm_do_event(self, IRCOMM_DATA_REQUEST, skb, NULL); ircomm_data_request()
313 * Function ircomm_data_indication (self, skb)
318 void ircomm_data_indication(struct ircomm_cb *self, struct sk_buff *skb) ircomm_data_indication() argument
322 if (self->notify.data_indication) ircomm_data_indication()
323 self->notify.data_indication(self->notify.instance, self, skb); ircomm_data_indication()
330 * Function ircomm_process_data (self, skb)
335 void ircomm_process_data(struct ircomm_cb *self, struct sk_buff *skb) ircomm_process_data() argument
361 ircomm_control_indication(self, skb, clen); ircomm_process_data()
367 ircomm_data_indication(self, skb); ircomm_process_data()
375 * Function ircomm_control_request (self, params)
380 int ircomm_control_request(struct ircomm_cb *self, struct sk_buff *skb) ircomm_control_request() argument
384 IRDA_ASSERT(self != NULL, return -EFAULT;); ircomm_control_request()
385 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EFAULT;); ircomm_control_request()
388 ret = ircomm_do_event(self, IRCOMM_CONTROL_REQUEST, skb, NULL); ircomm_control_request()
396 * Function ircomm_control_indication (self, skb)
401 static void ircomm_control_indication(struct ircomm_cb *self, ircomm_control_indication() argument
405 if (self->notify.udata_indication) { ircomm_control_indication()
416 self->notify.udata_indication(self->notify.instance, self, ircomm_control_indication()
428 * Function ircomm_disconnect_request (self, userdata, priority)
433 int ircomm_disconnect_request(struct ircomm_cb *self, struct sk_buff *userdata) ircomm_disconnect_request() argument
438 IRDA_ASSERT(self != NULL, return -1;); ircomm_disconnect_request()
439 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;); ircomm_disconnect_request()
441 ret = ircomm_do_event(self, IRCOMM_DISCONNECT_REQUEST, userdata, ircomm_disconnect_request()
449 * Function disconnect_indication (self, skb)
454 void ircomm_disconnect_indication(struct ircomm_cb *self, struct sk_buff *skb, ircomm_disconnect_indication() argument
459 if (self->notify.disconnect_indication) { ircomm_disconnect_indication()
460 self->notify.disconnect_indication(self->notify.instance, self, ircomm_disconnect_indication()
468 * Function ircomm_flow_request (self, flow)
473 void ircomm_flow_request(struct ircomm_cb *self, LOCAL_FLOW flow) ircomm_flow_request() argument
475 IRDA_ASSERT(self != NULL, return;); ircomm_flow_request()
476 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_flow_request()
478 if (self->service_type == IRCOMM_3_WIRE_RAW) ircomm_flow_request()
481 irttp_flow_request(self->tsap, flow); ircomm_flow_request()
489 struct ircomm_cb *self; ircomm_seq_start() local
494 for (self = (struct ircomm_cb *) hashbin_get_first(ircomm); ircomm_seq_start()
495 self != NULL; ircomm_seq_start()
496 self = (struct ircomm_cb *) hashbin_get_next(ircomm)) { ircomm_seq_start()
501 return self; ircomm_seq_start()
518 const struct ircomm_cb *self = v; ircomm_seq_show() local
520 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EINVAL; ); ircomm_seq_show()
522 if(self->line < 0x10) ircomm_seq_show()
523 seq_printf(seq, "ircomm%d", self->line); ircomm_seq_show()
525 seq_printf(seq, "irlpt%d", self->line - 0x10); ircomm_seq_show()
529 ircomm_state[ self->state], ircomm_seq_show()
530 self->slsap_sel, self->dlsap_sel); ircomm_seq_show()
532 if(self->service_type & IRCOMM_3_WIRE_RAW) ircomm_seq_show()
534 if(self->service_type & IRCOMM_3_WIRE) ircomm_seq_show()
536 if(self->service_type & IRCOMM_9_WIRE) ircomm_seq_show()
538 if(self->service_type & IRCOMM_CENTRONICS) ircomm_seq_show()
|
| H A D | ircomm_tty.c | 68 static void ircomm_tty_shutdown(struct ircomm_tty_cb *self);
110 struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb, ircomm_port_raise_dtr_rts() local
118 self->settings.dte |= IRCOMM_RTS | IRCOMM_DTR; ircomm_port_raise_dtr_rts()
120 self->settings.dte &= ~(IRCOMM_RTS | IRCOMM_DTR); ircomm_port_raise_dtr_rts()
122 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_port_raise_dtr_rts()
127 struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb, ircomm_port_carrier_raised() local
129 return self->settings.dce & IRCOMM_CD; ircomm_port_carrier_raised()
175 static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self) __ircomm_tty_cleanup() argument
177 IRDA_ASSERT(self != NULL, return;); __ircomm_tty_cleanup()
178 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); __ircomm_tty_cleanup()
180 ircomm_tty_shutdown(self); __ircomm_tty_cleanup()
182 self->magic = 0; __ircomm_tty_cleanup()
183 tty_port_destroy(&self->port); __ircomm_tty_cleanup()
184 kfree(self); __ircomm_tty_cleanup()
209 * Function ircomm_startup (self)
214 static int ircomm_tty_startup(struct ircomm_tty_cb *self) ircomm_tty_startup() argument
219 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_startup()
220 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_startup()
223 if (test_and_set_bit(ASYNCB_INITIALIZED, &self->port.flags)) { ircomm_tty_startup()
240 notify.instance = self; ircomm_tty_startup()
242 if (!self->ircomm) { ircomm_tty_startup()
243 self->ircomm = ircomm_open(¬ify, self->service_type, ircomm_tty_startup()
244 self->line); ircomm_tty_startup()
246 if (!self->ircomm) ircomm_tty_startup()
249 self->slsap_sel = self->ircomm->slsap_sel; ircomm_tty_startup()
252 ret = ircomm_tty_attach_cable(self); ircomm_tty_startup()
260 clear_bit(ASYNCB_INITIALIZED, &self->port.flags); ircomm_tty_startup()
265 * Function ircomm_block_til_ready (self, filp)
270 static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, ircomm_tty_block_til_ready() argument
273 struct tty_port *port = &self->port; ircomm_tty_block_til_ready()
340 self->state == IRCOMM_TTY_READY) ircomm_tty_block_til_ready()
377 struct ircomm_tty_cb *self; ircomm_tty_install() local
381 self = hashbin_lock_find(ircomm_tty, line, NULL); ircomm_tty_install()
382 if (!self) { ircomm_tty_install()
384 self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL); ircomm_tty_install()
385 if (self == NULL) ircomm_tty_install()
388 tty_port_init(&self->port); ircomm_tty_install()
389 self->port.ops = &ircomm_port_ops; ircomm_tty_install()
390 self->magic = IRCOMM_TTY_MAGIC; ircomm_tty_install()
391 self->flow = FLOW_STOP; ircomm_tty_install()
393 self->line = line; ircomm_tty_install()
394 INIT_WORK(&self->tqueue, ircomm_tty_do_softint); ircomm_tty_install()
395 self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED; ircomm_tty_install()
396 self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED; ircomm_tty_install()
399 init_timer(&self->watchdog_timer); ircomm_tty_install()
400 spin_lock_init(&self->spinlock); ircomm_tty_install()
413 hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL); ircomm_tty_install()
416 tty->driver_data = self; ircomm_tty_install()
418 return tty_port_install(&self->port, driver, tty); ircomm_tty_install()
430 struct ircomm_tty_cb *self = tty->driver_data; ircomm_tty_open() local
435 spin_lock_irqsave(&self->port.lock, flags); ircomm_tty_open()
436 self->port.count++; ircomm_tty_open()
437 spin_unlock_irqrestore(&self->port.lock, flags); ircomm_tty_open()
438 tty_port_tty_set(&self->port, tty); ircomm_tty_open()
441 self->line, self->port.count); ircomm_tty_open()
444 self->port.low_latency = (self->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0; ircomm_tty_open()
449 if (test_bit(ASYNCB_CLOSING, &self->port.flags)) { ircomm_tty_open()
459 if (wait_event_interruptible(self->port.close_wait, ircomm_tty_open()
460 !test_bit(ASYNCB_CLOSING, &self->port.flags))) { ircomm_tty_open()
467 return (self->port.flags & ASYNC_HUP_NOTIFY) ? ircomm_tty_open()
475 if (self->line < 0x10) { ircomm_tty_open()
476 self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE; ircomm_tty_open()
477 self->settings.service_type = IRCOMM_9_WIRE; /* 9 wire as default */ ircomm_tty_open()
479 self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI; /* Default line settings */ ircomm_tty_open()
483 self->service_type = IRCOMM_3_WIRE_RAW; ircomm_tty_open()
484 self->settings.service_type = IRCOMM_3_WIRE_RAW; /* Default */ ircomm_tty_open()
487 ret = ircomm_tty_startup(self); ircomm_tty_open()
491 ret = ircomm_tty_block_til_ready(self, tty, filp); ircomm_tty_open()
509 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_close() local
510 struct tty_port *port = &self->port; ircomm_tty_close()
512 IRDA_ASSERT(self != NULL, return;); ircomm_tty_close()
513 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_close()
518 ircomm_tty_shutdown(self); ircomm_tty_close()
534 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_flush_buffer() local
536 IRDA_ASSERT(self != NULL, return;); ircomm_tty_flush_buffer()
537 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_flush_buffer()
543 schedule_work(&self->tqueue); ircomm_tty_flush_buffer()
555 struct ircomm_tty_cb *self = ircomm_tty_do_softint() local
561 if (!self || self->magic != IRCOMM_TTY_MAGIC) ircomm_tty_do_softint()
564 tty = tty_port_tty_get(&self->port); ircomm_tty_do_softint()
569 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_do_softint()
571 ctrl_skb = self->ctrl_skb; ircomm_tty_do_softint()
572 self->ctrl_skb = NULL; ircomm_tty_do_softint()
574 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_do_softint()
578 if(self->flow == FLOW_START) ircomm_tty_do_softint()
579 ircomm_control_request(self->ircomm, ctrl_skb); ircomm_tty_do_softint()
588 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_do_softint()
590 skb = self->tx_skb; ircomm_tty_do_softint()
591 self->tx_skb = NULL; ircomm_tty_do_softint()
593 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_do_softint()
597 ircomm_tty_do_event(self, IRCOMM_TTY_DATA_REQUEST, skb, NULL); ircomm_tty_do_softint()
619 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_write() local
629 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_write()
630 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_write()
648 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) { ircomm_tty_write()
659 /* Protect our manipulation of self->tx_skb and related */ ircomm_tty_write()
660 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_write()
663 skb = self->tx_skb; ircomm_tty_write()
677 if (size > self->max_data_size) ircomm_tty_write()
678 size = self->max_data_size; ircomm_tty_write()
694 if ((tailroom = (self->tx_data_size - skb->len)) > 0) { ircomm_tty_write()
707 skb = alloc_skb(self->max_data_size+ ircomm_tty_write()
708 self->max_header_size, ircomm_tty_write()
711 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_write()
714 skb_reserve(skb, self->max_header_size); ircomm_tty_write()
715 self->tx_skb = skb; ircomm_tty_write()
718 self->tx_data_size = self->max_data_size; ircomm_tty_write()
728 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_write()
737 schedule_work(&self->tqueue); ircomm_tty_write()
751 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_write_room() local
755 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_write_room()
756 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_write_room()
760 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) ircomm_tty_write_room()
771 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_write_room()
772 if (self->tx_skb) ircomm_tty_write_room()
773 ret = self->tx_data_size - self->tx_skb->len; ircomm_tty_write_room()
775 ret = self->max_data_size; ircomm_tty_write_room()
776 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_write_room()
791 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_wait_until_sent() local
795 IRDA_ASSERT(self != NULL, return;); ircomm_tty_wait_until_sent()
796 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_wait_until_sent()
805 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_wait_until_sent()
806 while (self->tx_skb && self->tx_skb->len) { ircomm_tty_wait_until_sent()
807 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_wait_until_sent()
809 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_wait_until_sent()
815 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_wait_until_sent()
828 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_throttle() local
830 IRDA_ASSERT(self != NULL, return;); ircomm_tty_throttle()
831 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_throttle()
839 self->settings.dte &= ~IRCOMM_RTS; ircomm_tty_throttle()
840 self->settings.dte |= IRCOMM_DELTA_RTS; ircomm_tty_throttle()
842 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_tty_throttle()
845 ircomm_flow_request(self->ircomm, FLOW_STOP); ircomm_tty_throttle()
857 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_unthrottle() local
859 IRDA_ASSERT(self != NULL, return;); ircomm_tty_unthrottle()
860 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_unthrottle()
869 self->settings.dte |= (IRCOMM_RTS|IRCOMM_DELTA_RTS); ircomm_tty_unthrottle()
871 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_tty_unthrottle()
874 ircomm_flow_request(self->ircomm, FLOW_START); ircomm_tty_unthrottle()
885 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_chars_in_buffer() local
889 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_chars_in_buffer()
890 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_chars_in_buffer()
892 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_chars_in_buffer()
894 if (self->tx_skb) ircomm_tty_chars_in_buffer()
895 len = self->tx_skb->len; ircomm_tty_chars_in_buffer()
897 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_chars_in_buffer()
902 static void ircomm_tty_shutdown(struct ircomm_tty_cb *self) ircomm_tty_shutdown() argument
906 IRDA_ASSERT(self != NULL, return;); ircomm_tty_shutdown()
907 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_shutdown()
909 if (!test_and_clear_bit(ASYNCB_INITIALIZED, &self->port.flags)) ircomm_tty_shutdown()
912 ircomm_tty_detach_cable(self); ircomm_tty_shutdown()
914 spin_lock_irqsave(&self->spinlock, flags); ircomm_tty_shutdown()
916 del_timer(&self->watchdog_timer); ircomm_tty_shutdown()
919 if (self->ctrl_skb) { ircomm_tty_shutdown()
920 dev_kfree_skb(self->ctrl_skb); ircomm_tty_shutdown()
921 self->ctrl_skb = NULL; ircomm_tty_shutdown()
925 if (self->tx_skb) { ircomm_tty_shutdown()
926 dev_kfree_skb(self->tx_skb); ircomm_tty_shutdown()
927 self->tx_skb = NULL; ircomm_tty_shutdown()
930 if (self->ircomm) { ircomm_tty_shutdown()
931 ircomm_close(self->ircomm); ircomm_tty_shutdown()
932 self->ircomm = NULL; ircomm_tty_shutdown()
935 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_tty_shutdown()
947 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_hangup() local
948 struct tty_port *port = &self->port; ircomm_tty_hangup()
951 IRDA_ASSERT(self != NULL, return;); ircomm_tty_hangup()
952 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_hangup()
955 ircomm_tty_shutdown(self); ircomm_tty_hangup()
989 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_start() local
991 ircomm_flow_request(self->ircomm, FLOW_START); ircomm_tty_start()
1002 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_stop() local
1004 IRDA_ASSERT(self != NULL, return;); ircomm_tty_stop()
1005 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_stop()
1007 ircomm_flow_request(self->ircomm, FLOW_STOP); ircomm_tty_stop()
1011 * Function ircomm_check_modem_status (self)
1017 void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self) ircomm_tty_check_modem_status() argument
1022 IRDA_ASSERT(self != NULL, return;); ircomm_tty_check_modem_status()
1023 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_check_modem_status()
1025 tty = tty_port_tty_get(&self->port); ircomm_tty_check_modem_status()
1027 status = self->settings.dce; ircomm_tty_check_modem_status()
1030 /*wake_up_interruptible(&self->delta_msr_wait);*/ ircomm_tty_check_modem_status()
1032 if ((self->port.flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) { ircomm_tty_check_modem_status()
1033 pr_debug("%s(), ircomm%d CD now %s...\n", __func__ , self->line, ircomm_tty_check_modem_status()
1037 wake_up_interruptible(&self->port.open_wait); ircomm_tty_check_modem_status()
1047 if (tty && tty_port_cts_enabled(&self->port)) { ircomm_tty_check_modem_status()
1054 wake_up_interruptible(&self->port.open_wait); ircomm_tty_check_modem_status()
1056 schedule_work(&self->tqueue); ircomm_tty_check_modem_status()
1079 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_tty_data_indication() local
1082 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_data_indication()
1083 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_data_indication()
1086 tty = tty_port_tty_get(&self->port); ircomm_tty_data_indication()
1098 if (tty->hw_stopped && (self->flow == FLOW_START)) { ircomm_tty_data_indication()
1100 ircomm_param_request(self, IRCOMM_POLL, TRUE); ircomm_tty_data_indication()
1103 ircomm_tty_send_initial_parameters(self); ircomm_tty_data_indication()
1104 ircomm_tty_link_established(self); ircomm_tty_data_indication()
1112 tty_insert_flip_string(&self->port, skb->data, skb->len); ircomm_tty_data_indication()
1113 tty_flip_buffer_push(&self->port); ircomm_tty_data_indication()
1129 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_tty_control_indication() local
1132 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_control_indication()
1133 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_control_indication()
1138 irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen), ircomm_tty_control_indication()
1156 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_tty_flow_indication() local
1159 IRDA_ASSERT(self != NULL, return;); ircomm_tty_flow_indication()
1160 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); ircomm_tty_flow_indication()
1162 tty = tty_port_tty_get(&self->port); ircomm_tty_flow_indication()
1171 schedule_work(&self->tqueue); ircomm_tty_flow_indication()
1182 self->flow = cmd; ircomm_tty_flow_indication()
1186 static void ircomm_tty_line_info(struct ircomm_tty_cb *self, struct seq_file *m) ircomm_tty_line_info() argument
1191 seq_printf(m, "State: %s\n", ircomm_tty_state[self->state]); ircomm_tty_line_info()
1194 if (self->service_type & IRCOMM_9_WIRE) ircomm_tty_line_info()
1196 else if (self->service_type & IRCOMM_3_WIRE) ircomm_tty_line_info()
1198 else if (self->service_type & IRCOMM_3_WIRE_RAW) ircomm_tty_line_info()
1204 seq_printf(m, "Port name: %s\n", self->settings.port_name); ircomm_tty_line_info()
1208 if (self->settings.dte & IRCOMM_RTS) { ircomm_tty_line_info()
1212 if (self->settings.dte & IRCOMM_DTR) { ircomm_tty_line_info()
1220 if (self->settings.dce & IRCOMM_CTS) { ircomm_tty_line_info()
1224 if (self->settings.dce & IRCOMM_DSR) { ircomm_tty_line_info()
1228 if (self->settings.dce & IRCOMM_CD) { ircomm_tty_line_info()
1232 if (self->settings.dce & IRCOMM_RI) { ircomm_tty_line_info()
1239 if (!self->settings.null_modem) ircomm_tty_line_info()
1244 seq_printf(m, "Data rate: %d\n", self->settings.data_rate); ircomm_tty_line_info()
1248 if (self->settings.flow_control & IRCOMM_XON_XOFF_IN) { ircomm_tty_line_info()
1252 if (self->settings.flow_control & IRCOMM_XON_XOFF_OUT) { ircomm_tty_line_info()
1256 if (self->settings.flow_control & IRCOMM_RTS_CTS_IN) { ircomm_tty_line_info()
1260 if (self->settings.flow_control & IRCOMM_RTS_CTS_OUT) { ircomm_tty_line_info()
1264 if (self->settings.flow_control & IRCOMM_DSR_DTR_IN) { ircomm_tty_line_info()
1268 if (self->settings.flow_control & IRCOMM_DSR_DTR_OUT) { ircomm_tty_line_info()
1272 if (self->settings.flow_control & IRCOMM_ENQ_ACK_IN) { ircomm_tty_line_info()
1276 if (self->settings.flow_control & IRCOMM_ENQ_ACK_OUT) { ircomm_tty_line_info()
1284 if (tty_port_cts_enabled(&self->port)) { ircomm_tty_line_info()
1288 if (self->port.flags & ASYNC_CHECK_CD) { ircomm_tty_line_info()
1292 if (self->port.flags & ASYNC_INITIALIZED) { ircomm_tty_line_info()
1296 if (self->port.flags & ASYNC_LOW_LATENCY) { ircomm_tty_line_info()
1300 if (self->port.flags & ASYNC_CLOSING) { ircomm_tty_line_info()
1304 if (self->port.flags & ASYNC_NORMAL_ACTIVE) { ircomm_tty_line_info()
1310 seq_printf(m, "Role: %s\n", self->client ? "client" : "server"); ircomm_tty_line_info()
1311 seq_printf(m, "Open count: %d\n", self->port.count); ircomm_tty_line_info()
1312 seq_printf(m, "Max data size: %d\n", self->max_data_size); ircomm_tty_line_info()
1313 seq_printf(m, "Max header size: %d\n", self->max_header_size); ircomm_tty_line_info()
1315 tty = tty_port_tty_get(&self->port); ircomm_tty_line_info()
1325 struct ircomm_tty_cb *self; ircomm_tty_proc_show() local
1330 self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty); ircomm_tty_proc_show()
1331 while (self != NULL) { ircomm_tty_proc_show()
1332 if (self->magic != IRCOMM_TTY_MAGIC) ircomm_tty_proc_show()
1335 ircomm_tty_line_info(self, m); ircomm_tty_proc_show()
1336 self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty); ircomm_tty_proc_show()
|
| H A D | ircomm_lmp.c | 44 * Function ircomm_lmp_connect_request (self, userdata)
49 static int ircomm_lmp_connect_request(struct ircomm_cb *self, ircomm_lmp_connect_request() argument
59 ret = irlmp_connect_request(self->lsap, info->dlsap_sel, ircomm_lmp_connect_request()
65 * Function ircomm_lmp_connect_response (self, skb)
70 static int ircomm_lmp_connect_response(struct ircomm_cb *self, ircomm_lmp_connect_response() argument
96 return irlmp_connect_response(self->lsap, tx_skb); ircomm_lmp_connect_response()
99 static int ircomm_lmp_disconnect_request(struct ircomm_cb *self, ircomm_lmp_disconnect_request() argument
119 ret = irlmp_disconnect_request(self->lsap, userdata); ircomm_lmp_disconnect_request()
134 struct ircomm_cb *self; ircomm_lmp_flow_control() local
143 self = (struct ircomm_cb *) hashbin_lock_find(ircomm, line, NULL); ircomm_lmp_flow_control()
144 if (!self) { ircomm_lmp_flow_control()
149 IRDA_ASSERT(self != NULL, return;); ircomm_lmp_flow_control()
150 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_lmp_flow_control()
152 self->pkt_count--; ircomm_lmp_flow_control()
154 if ((self->pkt_count < 2) && (self->flow_status == FLOW_STOP)) { ircomm_lmp_flow_control()
156 self->flow_status = FLOW_START; ircomm_lmp_flow_control()
157 if (self->notify.flow_indication) ircomm_lmp_flow_control()
158 self->notify.flow_indication(self->notify.instance, ircomm_lmp_flow_control()
159 self, FLOW_START); ircomm_lmp_flow_control()
164 * Function ircomm_lmp_data_request (self, userdata)
169 static int ircomm_lmp_data_request(struct ircomm_cb *self, ircomm_lmp_data_request() argument
180 cb->line = self->line; ircomm_lmp_data_request()
190 if ((self->pkt_count++ > 7) && (self->flow_status == FLOW_START)) { ircomm_lmp_data_request()
192 self->flow_status = FLOW_STOP; ircomm_lmp_data_request()
193 if (self->notify.flow_indication) ircomm_lmp_data_request()
194 self->notify.flow_indication(self->notify.instance, ircomm_lmp_data_request()
195 self, FLOW_STOP); ircomm_lmp_data_request()
197 ret = irlmp_data_request(self->lsap, skb); ircomm_lmp_data_request()
215 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_lmp_data_indication() local
217 IRDA_ASSERT(self != NULL, return -1;); ircomm_lmp_data_indication()
218 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;); ircomm_lmp_data_indication()
221 ircomm_do_event(self, IRCOMM_LMP_DATA_INDICATION, skb, NULL); ircomm_lmp_data_indication()
242 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_lmp_connect_confirm() local
245 IRDA_ASSERT(self != NULL, return;); ircomm_lmp_connect_confirm()
246 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_lmp_connect_confirm()
254 ircomm_do_event(self, IRCOMM_LMP_CONNECT_CONFIRM, skb, &info); ircomm_lmp_connect_confirm()
273 struct ircomm_cb *self = (struct ircomm_cb *)instance; ircomm_lmp_connect_indication() local
276 IRDA_ASSERT(self != NULL, return;); ircomm_lmp_connect_indication()
277 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_lmp_connect_indication()
285 ircomm_do_event(self, IRCOMM_LMP_CONNECT_INDICATION, skb, &info); ircomm_lmp_connect_indication()
301 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_lmp_disconnect_indication() local
304 IRDA_ASSERT(self != NULL, return;); ircomm_lmp_disconnect_indication()
305 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_lmp_disconnect_indication()
309 ircomm_do_event(self, IRCOMM_LMP_DISCONNECT_INDICATION, skb, &info); ircomm_lmp_disconnect_indication()
316 * Function ircomm_open_lsap (self)
321 int ircomm_open_lsap(struct ircomm_cb *self) ircomm_open_lsap() argument
331 notify.instance = self; ircomm_open_lsap()
334 self->lsap = irlmp_open_lsap(LSAP_ANY, ¬ify, 0); ircomm_open_lsap()
335 if (!self->lsap) { ircomm_open_lsap()
339 self->slsap_sel = self->lsap->slsap_sel; ircomm_open_lsap()
344 self->issue.data_request = ircomm_lmp_data_request; ircomm_open_lsap()
345 self->issue.connect_request = ircomm_lmp_connect_request; ircomm_open_lsap()
346 self->issue.connect_response = ircomm_lmp_connect_response; ircomm_open_lsap()
347 self->issue.disconnect_request = ircomm_lmp_disconnect_request; ircomm_open_lsap()
|
| H A D | ircomm_param.c | 93 * Function ircomm_param_request (self, pi, flush)
98 int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush) ircomm_param_request() argument
104 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_request()
105 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_request()
108 if (self->service_type == IRCOMM_3_WIRE_RAW) ircomm_param_request()
111 spin_lock_irqsave(&self->spinlock, flags); ircomm_param_request()
113 skb = self->ctrl_skb; ircomm_param_request()
117 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_param_request()
121 skb_reserve(skb, self->max_header_size); ircomm_param_request()
122 self->ctrl_skb = skb; ircomm_param_request()
128 count = irda_param_insert(self, pi, skb_tail_pointer(skb), ircomm_param_request()
133 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_param_request()
138 spin_unlock_irqrestore(&self->spinlock, flags); ircomm_param_request()
144 schedule_work(&self->tqueue); ircomm_param_request()
151 * Function ircomm_param_service_type (self, buf, len)
160 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_service_type() local
163 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_service_type()
164 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_service_type()
167 param->pv.i = self->settings.service_type; ircomm_param_service_type()
172 service_type &= self->service_type; ircomm_param_service_type()
184 self->settings.service_type = IRCOMM_CENTRONICS; ircomm_param_service_type()
186 self->settings.service_type = IRCOMM_9_WIRE; ircomm_param_service_type()
188 self->settings.service_type = IRCOMM_3_WIRE; ircomm_param_service_type()
190 self->settings.service_type = IRCOMM_3_WIRE_RAW; ircomm_param_service_type()
193 self->settings.service_type); ircomm_param_service_type()
200 * therefore before we even have open any socket. And self->client ircomm_param_service_type()
204 if ((self->max_header_size != IRCOMM_TTY_HDR_UNINITIALISED) && ircomm_param_service_type()
205 (!self->client) && ircomm_param_service_type()
206 (self->settings.service_type != IRCOMM_3_WIRE_RAW)) ircomm_param_service_type()
209 ircomm_tty_send_initial_parameters(self); ircomm_param_service_type()
210 ircomm_tty_link_established(self); ircomm_param_service_type()
217 * Function ircomm_param_port_type (self, param)
225 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_port_type() local
227 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_port_type()
228 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_port_type()
233 self->settings.port_type = (__u8) param->pv.i; ircomm_param_port_type()
236 self->settings.port_type); ircomm_param_port_type()
242 * Function ircomm_param_port_name (self, param)
249 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_port_name() local
251 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_port_name()
252 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_port_name()
258 strncpy(self->settings.port_name, param->pv.c, 32); ircomm_param_port_name()
265 * Function ircomm_param_data_rate (self, param)
272 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_data_rate() local
274 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_data_rate()
275 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_data_rate()
278 param->pv.i = self->settings.data_rate; ircomm_param_data_rate()
280 self->settings.data_rate = param->pv.i; ircomm_param_data_rate()
288 * Function ircomm_param_data_format (self, param)
296 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_data_format() local
298 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_data_format()
299 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_data_format()
302 param->pv.i = self->settings.data_format; ircomm_param_data_format()
304 self->settings.data_format = (__u8) param->pv.i; ircomm_param_data_format()
310 * Function ircomm_param_flow_control (self, param)
318 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_flow_control() local
320 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_flow_control()
321 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_flow_control()
324 param->pv.i = self->settings.flow_control; ircomm_param_flow_control()
326 self->settings.flow_control = (__u8) param->pv.i; ircomm_param_flow_control()
334 * Function ircomm_param_xon_xoff (self, param)
341 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_xon_xoff() local
343 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_xon_xoff()
344 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_xon_xoff()
347 param->pv.i = self->settings.xonxoff[0]; ircomm_param_xon_xoff()
348 param->pv.i |= self->settings.xonxoff[1] << 8; ircomm_param_xon_xoff()
350 self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff; ircomm_param_xon_xoff()
351 self->settings.xonxoff[1] = (__u16) param->pv.i >> 8; ircomm_param_xon_xoff()
361 * Function ircomm_param_enq_ack (self, param)
368 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_enq_ack() local
370 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_enq_ack()
371 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_enq_ack()
374 param->pv.i = self->settings.enqack[0]; ircomm_param_enq_ack()
375 param->pv.i |= self->settings.enqack[1] << 8; ircomm_param_enq_ack()
377 self->settings.enqack[0] = (__u16) param->pv.i & 0xff; ircomm_param_enq_ack()
378 self->settings.enqack[1] = (__u16) param->pv.i >> 8; ircomm_param_enq_ack()
388 * Function ircomm_param_line_status (self, param)
409 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_dte() local
412 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_dte()
413 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_dte()
416 param->pv.i = self->settings.dte; ircomm_param_dte()
420 self->settings.dce = 0; ircomm_param_dte()
423 self->settings.dce |= (IRCOMM_DELTA_DSR| ircomm_param_dte()
427 self->settings.dce |= (IRCOMM_DSR| ircomm_param_dte()
432 self->settings.dce |= IRCOMM_DELTA_CTS; ircomm_param_dte()
434 self->settings.dce |= IRCOMM_CTS; ircomm_param_dte()
437 ircomm_tty_check_modem_status(self); ircomm_param_dte()
440 self->settings.null_modem = TRUE; ircomm_param_dte()
454 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_dce() local
461 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_dce()
462 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_dce()
464 self->settings.dce = dce; ircomm_param_dce()
473 ircomm_tty_check_modem_status(self); ircomm_param_dce()
486 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; ircomm_param_poll() local
488 IRDA_ASSERT(self != NULL, return -1;); ircomm_param_poll()
489 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_param_poll()
494 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_param_poll()
|
| H A D | ircomm_tty_ioctl.c | 53 static void ircomm_tty_change_speed(struct ircomm_tty_cb *self, ircomm_tty_change_speed() argument
59 if (!self->ircomm) ircomm_tty_change_speed()
85 self->settings.data_rate = baud; ircomm_tty_change_speed()
86 ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE); ircomm_tty_change_speed()
90 self->port.flags |= ASYNC_CTS_FLOW; ircomm_tty_change_speed()
91 self->settings.flow_control |= IRCOMM_RTS_CTS_IN; ircomm_tty_change_speed()
93 if (self->service_type == IRCOMM_3_WIRE_RAW) ircomm_tty_change_speed()
97 self->port.flags &= ~ASYNC_CTS_FLOW; ircomm_tty_change_speed()
98 self->settings.flow_control &= ~IRCOMM_RTS_CTS_IN; ircomm_tty_change_speed()
101 self->port.flags &= ~ASYNC_CHECK_CD; ircomm_tty_change_speed()
103 self->port.flags |= ASYNC_CHECK_CD; ircomm_tty_change_speed()
109 if (I_INPCK(self->tty)) ircomm_tty_change_speed()
121 if (I_IGNBRK(self->tty)) { ircomm_tty_change_speed()
122 self->ignore_status_mask |= LSR_BI; ircomm_tty_change_speed()
127 if (I_IGNPAR(self->tty)) ircomm_tty_change_speed()
128 self->ignore_status_mask |= LSR_OE; ircomm_tty_change_speed()
131 self->settings.data_format = cval; ircomm_tty_change_speed()
133 ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE); ircomm_tty_change_speed()
134 ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE); ircomm_tty_change_speed()
148 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_set_termios() local
158 ircomm_tty_change_speed(self, tty); ircomm_tty_set_termios()
163 self->settings.dte &= ~(IRCOMM_DTR|IRCOMM_RTS); ircomm_tty_set_termios()
164 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_tty_set_termios()
170 self->settings.dte |= IRCOMM_DTR; ircomm_tty_set_termios()
173 self->settings.dte |= IRCOMM_RTS; ircomm_tty_set_termios()
175 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_tty_set_termios()
195 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_tiocmget() local
201 result = ((self->settings.dte & IRCOMM_RTS) ? TIOCM_RTS : 0) ircomm_tty_tiocmget()
202 | ((self->settings.dte & IRCOMM_DTR) ? TIOCM_DTR : 0) ircomm_tty_tiocmget()
203 | ((self->settings.dce & IRCOMM_CD) ? TIOCM_CAR : 0) ircomm_tty_tiocmget()
204 | ((self->settings.dce & IRCOMM_RI) ? TIOCM_RNG : 0) ircomm_tty_tiocmget()
205 | ((self->settings.dce & IRCOMM_DSR) ? TIOCM_DSR : 0) ircomm_tty_tiocmget()
206 | ((self->settings.dce & IRCOMM_CTS) ? TIOCM_CTS : 0); ircomm_tty_tiocmget()
219 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_tiocmset() local
224 IRDA_ASSERT(self != NULL, return -1;); ircomm_tty_tiocmset()
225 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); ircomm_tty_tiocmset()
228 self->settings.dte |= IRCOMM_RTS; ircomm_tty_tiocmset()
230 self->settings.dte |= IRCOMM_DTR; ircomm_tty_tiocmset()
233 self->settings.dte &= ~IRCOMM_RTS; ircomm_tty_tiocmset()
235 self->settings.dte &= ~IRCOMM_DTR; ircomm_tty_tiocmset()
238 self->settings.dte |= IRCOMM_DELTA_RTS; ircomm_tty_tiocmset()
240 self->settings.dte |= IRCOMM_DELTA_DTR; ircomm_tty_tiocmset()
242 ircomm_param_request(self, IRCOMM_DTE, TRUE); ircomm_tty_tiocmset()
253 static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self, ircomm_tty_get_serial_info() argument
262 info.line = self->line; ircomm_tty_get_serial_info()
263 info.flags = self->port.flags; ircomm_tty_get_serial_info()
264 info.baud_base = self->settings.data_rate; ircomm_tty_get_serial_info()
265 info.close_delay = self->port.close_delay; ircomm_tty_get_serial_info()
266 info.closing_wait = self->port.closing_wait; ircomm_tty_get_serial_info()
288 static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self, ircomm_tty_set_serial_info() argument
299 state = self ircomm_tty_set_serial_info()
300 old_state = *self; ircomm_tty_set_serial_info()
306 (self->flags & ~ASYNC_USR_MASK))) ircomm_tty_set_serial_info()
310 self->flags = ((self->flags & ~ASYNC_USR_MASK) | ircomm_tty_set_serial_info()
312 /* self->custom_divisor = new_serial.custom_divisor; */ ircomm_tty_set_serial_info()
321 if (self->settings.data_rate != new_serial.baud_base) { ircomm_tty_set_serial_info()
322 self->settings.data_rate = new_serial.baud_base; ircomm_tty_set_serial_info()
323 ircomm_param_request(self, IRCOMM_DATA_RATE, TRUE); ircomm_tty_set_serial_info()
326 self->close_delay = new_serial.close_delay * HZ/100; ircomm_tty_set_serial_info()
327 self->closing_wait = new_serial.closing_wait * HZ/100; ircomm_tty_set_serial_info()
328 /* self->custom_divisor = new_serial.custom_divisor; */ ircomm_tty_set_serial_info()
330 self->flags = ((self->flags & ~ASYNC_FLAGS) | ircomm_tty_set_serial_info()
332 self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0; ircomm_tty_set_serial_info()
336 if (self->flags & ASYNC_INITIALIZED) { ircomm_tty_set_serial_info()
338 (self->flags & ASYNC_SPD_MASK)) || ircomm_tty_set_serial_info()
364 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; ircomm_tty_ioctl() local
376 ret = ircomm_tty_get_serial_info(self, (struct serial_struct __user *) arg); ircomm_tty_ioctl()
379 ret = ircomm_tty_set_serial_info(self, (struct serial_struct __user *) arg); ircomm_tty_ioctl()
|
| H A D | ircomm_ttp.c | 57 static int ircomm_ttp_data_request(struct ircomm_cb *self,
60 static int ircomm_ttp_connect_request(struct ircomm_cb *self,
63 static int ircomm_ttp_connect_response(struct ircomm_cb *self,
65 static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
70 * Function ircomm_open_tsap (self)
75 int ircomm_open_tsap(struct ircomm_cb *self) ircomm_open_tsap() argument
86 notify.instance = self; ircomm_open_tsap()
89 self->tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, ircomm_open_tsap()
91 if (!self->tsap) { ircomm_open_tsap()
95 self->slsap_sel = self->tsap->stsap_sel; ircomm_open_tsap()
100 self->issue.data_request = ircomm_ttp_data_request; ircomm_open_tsap()
101 self->issue.connect_request = ircomm_ttp_connect_request; ircomm_open_tsap()
102 self->issue.connect_response = ircomm_ttp_connect_response; ircomm_open_tsap()
103 self->issue.disconnect_request = ircomm_ttp_disconnect_request; ircomm_open_tsap()
109 * Function ircomm_ttp_connect_request (self, userdata)
114 static int ircomm_ttp_connect_request(struct ircomm_cb *self, ircomm_ttp_connect_request() argument
124 ret = irttp_connect_request(self->tsap, info->dlsap_sel, ircomm_ttp_connect_request()
132 * Function ircomm_ttp_connect_response (self, skb)
137 static int ircomm_ttp_connect_response(struct ircomm_cb *self, ircomm_ttp_connect_response() argument
146 ret = irttp_connect_response(self->tsap, TTP_SAR_DISABLE, userdata); ircomm_ttp_connect_response()
152 * Function ircomm_ttp_data_request (self, userdata)
160 static int ircomm_ttp_data_request(struct ircomm_cb *self, ircomm_ttp_data_request() argument
183 ret = irttp_data_request(self->tsap, skb); ircomm_ttp_data_request()
201 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_ttp_data_indication() local
203 IRDA_ASSERT(self != NULL, return -1;); ircomm_ttp_data_indication()
204 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;); ircomm_ttp_data_indication()
207 ircomm_do_event(self, IRCOMM_TTP_DATA_INDICATION, skb, NULL); ircomm_ttp_data_indication()
221 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_ttp_connect_confirm() local
224 IRDA_ASSERT(self != NULL, return;); ircomm_ttp_connect_confirm()
225 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_ttp_connect_confirm()
235 info.max_data_size = irttp_get_max_seg_size(self->tsap) ircomm_ttp_connect_confirm()
240 ircomm_do_event(self, IRCOMM_TTP_CONNECT_CONFIRM, skb, &info); ircomm_ttp_connect_confirm()
260 struct ircomm_cb *self = (struct ircomm_cb *)instance; ircomm_ttp_connect_indication() local
263 IRDA_ASSERT(self != NULL, return;); ircomm_ttp_connect_indication()
264 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_ttp_connect_indication()
274 info.max_data_size = irttp_get_max_seg_size(self->tsap) ircomm_ttp_connect_indication()
279 ircomm_do_event(self, IRCOMM_TTP_CONNECT_INDICATION, skb, &info); ircomm_ttp_connect_indication()
287 * Function ircomm_ttp_disconnect_request (self, userdata, info)
292 static int ircomm_ttp_disconnect_request(struct ircomm_cb *self, ircomm_ttp_disconnect_request() argument
302 ret = irttp_disconnect_request(self->tsap, userdata, P_NORMAL); ircomm_ttp_disconnect_request()
317 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_ttp_disconnect_indication() local
320 IRDA_ASSERT(self != NULL, return;); ircomm_ttp_disconnect_indication()
321 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_ttp_disconnect_indication()
325 ircomm_do_event(self, IRCOMM_TTP_DISCONNECT_INDICATION, skb, &info); ircomm_ttp_disconnect_indication()
341 struct ircomm_cb *self = (struct ircomm_cb *) instance; ircomm_ttp_flow_indication() local
343 IRDA_ASSERT(self != NULL, return;); ircomm_ttp_flow_indication()
344 IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); ircomm_ttp_flow_indication()
346 if (self->notify.flow_indication) ircomm_ttp_flow_indication()
347 self->notify.flow_indication(self->notify.instance, self, cmd); ircomm_ttp_flow_indication()
|
| H A D | ircomm_event.c | 41 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
43 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
45 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
47 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
76 static int (*state[])(struct ircomm_cb *self, IRCOMM_EVENT event,
86 * Function ircomm_state_idle (self, event, skb)
91 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event, ircomm_state_idle() argument
98 ircomm_next_state(self, IRCOMM_WAITI); ircomm_state_idle()
99 ret = self->issue.connect_request(self, skb, info); ircomm_state_idle()
103 ircomm_next_state(self, IRCOMM_WAITR); ircomm_state_idle()
104 ircomm_connect_indication(self, skb, info); ircomm_state_idle()
115 * Function ircomm_state_waiti (self, event, skb)
120 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event, ircomm_state_waiti() argument
128 ircomm_next_state(self, IRCOMM_CONN); ircomm_state_waiti()
129 ircomm_connect_confirm(self, skb, info); ircomm_state_waiti()
133 ircomm_next_state(self, IRCOMM_IDLE); ircomm_state_waiti()
134 ircomm_disconnect_indication(self, skb, info); ircomm_state_waiti()
145 * Function ircomm_state_waitr (self, event, skb)
150 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event, ircomm_state_waitr() argument
157 ircomm_next_state(self, IRCOMM_CONN); ircomm_state_waitr()
158 ret = self->issue.connect_response(self, skb); ircomm_state_waitr()
161 ircomm_next_state(self, IRCOMM_IDLE); ircomm_state_waitr()
162 ret = self->issue.disconnect_request(self, skb, info); ircomm_state_waitr()
166 ircomm_next_state(self, IRCOMM_IDLE); ircomm_state_waitr()
167 ircomm_disconnect_indication(self, skb, info); ircomm_state_waitr()
178 * Function ircomm_state_conn (self, event, skb)
183 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event, ircomm_state_conn() argument
190 ret = self->issue.data_request(self, skb, 0); ircomm_state_conn()
193 ircomm_process_data(self, skb); ircomm_state_conn()
196 ircomm_data_indication(self, skb); ircomm_state_conn()
200 ret = self->issue.data_request(self, skb, skb->len); ircomm_state_conn()
204 ircomm_next_state(self, IRCOMM_IDLE); ircomm_state_conn()
205 ircomm_disconnect_indication(self, skb, info); ircomm_state_conn()
208 ircomm_next_state(self, IRCOMM_IDLE); ircomm_state_conn()
209 ret = self->issue.disconnect_request(self, skb, info); ircomm_state_conn()
220 * Function ircomm_do_event (self, event, skb)
225 int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event, ircomm_do_event() argument
229 ircomm_state[self->state], ircomm_event[event]); ircomm_do_event()
231 return (*state[self->state])(self, event, skb, info); ircomm_do_event()
235 * Function ircomm_next_state (self, state)
240 void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state) ircomm_next_state() argument
242 self->state = state; ircomm_next_state()
245 ircomm_state[self->state], self->service_type); ircomm_next_state()
|
| /linux-4.1.27/tools/perf/scripts/python/ |
| H A D | sched-migration.py | 39 def __repr__(self):
47 def __init__(self, sleeper):
48 self.sleeper = sleeper
50 def __repr__(self):
51 return "%s gone to sleep" % thread_name(self.sleeper)
58 def __init__(self, wakee):
59 self.wakee = wakee
61 def __repr__(self):
62 return "%s woke up" % thread_name(self.wakee)
69 def __init__(self, child):
70 self.child = child
72 def __repr__(self):
73 return "new forked task %s" % thread_name(self.child)
80 def __init__(self, new):
81 self.new = new
83 def __repr__(self):
84 return "task migrated in %s" % thread_name(self.new)
91 def __init__(self, old):
92 self.old = old
94 def __repr__(self):
95 return "task migrated out %s" % thread_name(self.old)
98 def __init__(self, tasks = [0], event = RunqueueEventUnknown()):
99 self.tasks = tuple(tasks)
100 self.event = event
102 def sched_switch(self, prev, prev_state, next):
105 if taskState(prev_state) == "R" and next in self.tasks \
106 and prev in self.tasks:
107 return self
112 next_tasks = list(self.tasks[:])
113 if prev in self.tasks:
124 def migrate_out(self, old):
125 if old not in self.tasks:
126 return self
127 next_tasks = [task for task in self.tasks if task != old]
131 def __migrate_in(self, new, event):
132 if new in self.tasks:
133 self.event = event
134 return self
135 next_tasks = self.tasks[:] + tuple([new])
139 def migrate_in(self, new):
140 return self.__migrate_in(new, RunqueueMigrateIn(new))
142 def wake_up(self, new):
143 return self.__migrate_in(new, RunqueueEventWakeup(new))
145 def wake_up_new(self, new):
146 return self.__migrate_in(new, RunqueueEventFork(new))
148 def load(self):
151 return len(self.tasks) - 1
153 def __repr__(self):
154 ret = self.tasks.__repr__()
155 ret += self.origin_tostring()
160 def __init__(self, start, prev):
161 self.start = start
162 self.prev = prev
163 self.end = start
165 self.event_cpus = []
167 self.total_load = prev.total_load
168 self.rqs = prev.rqs.copy()
170 self.rqs = defaultdict(RunqueueSnapshot)
171 self.total_load = 0
173 def __update_total_load(self, old_rq, new_rq):
175 self.total_load += diff
177 def sched_switch(self, ts_list, prev, prev_state, next, cpu):
178 old_rq = self.prev.rqs[cpu]
184 self.rqs[cpu] = new_rq
185 self.__update_total_load(old_rq, new_rq)
186 ts_list.append(self)
187 self.event_cpus = [cpu]
189 def migrate(self, ts_list, new, old_cpu, new_cpu):
192 old_rq = self.prev.rqs[old_cpu]
194 self.rqs[old_cpu] = out_rq
195 self.__update_total_load(old_rq, out_rq)
197 new_rq = self.prev.rqs[new_cpu]
199 self.rqs[new_cpu] = in_rq
200 self.__update_total_load(new_rq, in_rq)
202 ts_list.append(self)
205 self.event_cpus.append(old_cpu)
206 self.event_cpus.append(new_cpu)
208 def wake_up(self, ts_list, pid, cpu, fork):
209 old_rq = self.prev.rqs[cpu]
217 self.rqs[cpu] = new_rq
218 self.__update_total_load(old_rq, new_rq)
219 ts_list.append(self)
220 self.event_cpus = [cpu]
222 def next(self, t):
223 self.end = t
224 return TimeSlice(t, self)
227 def __init__(self, arg = []):
228 self.data = arg
230 def get_time_slice(self, ts):
231 if len(self.data) == 0:
234 slice = self.data[-1].next(ts)
237 def find_time_slice(self, ts):
239 end = len(self.data)
247 if self.data[i].start <= ts and self.data[i].end >= ts:
252 if self.data[i].end < ts:
255 elif self.data[i].start > ts:
260 def set_root_win(self, win):
261 self.root_win = win
263 def mouse_down(self, cpu, t):
264 idx = self.find_time_slice(t)
268 ts = self[idx]
278 self.root_win.update_summary(raw)
280 def update_rectangle_cpu(self, slice, cpu):
296 self.root_win.paint_rectangle_zone(cpu, color, top_color, slice.start, slice.end)
298 def fill_zone(self, start, end):
299 i = self.find_time_slice(start)
303 for i in xrange(i, len(self.data)):
304 timeslice = self.data[i]
309 self.update_rectangle_cpu(timeslice, cpu)
311 def interval(self):
312 if len(self.data) == 0:
315 return (self.data[0].start, self.data[-1].end)
317 def nr_rectangles(self):
318 last_ts = self.data[-1]
327 def __init__(self):
328 self.current_tsk = defaultdict(lambda : -1)
329 self.timeslices = TimeSliceList()
331 def sched_switch(self, headers, prev_comm, prev_pid, prev_prio, prev_state,
336 on_cpu_task = self.current_tsk[headers.cpu]
344 self.current_tsk[headers.cpu] = next_pid
346 ts = self.timeslices.get_time_slice(headers.ts())
347 ts.sched_switch(self.timeslices, prev_pid, prev_state, next_pid, headers.cpu)
349 def migrate(self, headers, pid, prio, orig_cpu, dest_cpu):
350 ts = self.timeslices.get_time_slice(headers.ts())
351 ts.migrate(self.timeslices, pid, orig_cpu, dest_cpu)
353 def wake_up(self, headers, comm, pid, success, target_cpu, fork):
356 ts = self.timeslices.get_time_slice(headers.ts())
357 ts.wake_up(self.timeslices, pid, target_cpu, fork)
|
| /linux-4.1.27/net/irda/ |
| H A D | irlap_event.c | 50 static int irlap_state_ndm (struct irlap_cb *self, IRLAP_EVENT event,
52 static int irlap_state_query (struct irlap_cb *self, IRLAP_EVENT event,
54 static int irlap_state_reply (struct irlap_cb *self, IRLAP_EVENT event,
56 static int irlap_state_conn (struct irlap_cb *self, IRLAP_EVENT event,
58 static int irlap_state_setup (struct irlap_cb *self, IRLAP_EVENT event,
60 static int irlap_state_offline(struct irlap_cb *self, IRLAP_EVENT event,
62 static int irlap_state_xmit_p (struct irlap_cb *self, IRLAP_EVENT event,
64 static int irlap_state_pclose (struct irlap_cb *self, IRLAP_EVENT event,
66 static int irlap_state_nrm_p (struct irlap_cb *self, IRLAP_EVENT event,
68 static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
70 static int irlap_state_reset (struct irlap_cb *self, IRLAP_EVENT event,
72 static int irlap_state_nrm_s (struct irlap_cb *self, IRLAP_EVENT event,
74 static int irlap_state_xmit_s (struct irlap_cb *self, IRLAP_EVENT event,
76 static int irlap_state_sclose (struct irlap_cb *self, IRLAP_EVENT event,
140 static int (*state[])(struct irlap_cb *self, IRLAP_EVENT event,
168 struct irlap_cb *self = (struct irlap_cb *) data; irlap_poll_timer_expired() local
170 IRDA_ASSERT(self != NULL, return;); irlap_poll_timer_expired()
171 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_poll_timer_expired()
173 irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL); irlap_poll_timer_expired()
182 static void irlap_start_poll_timer(struct irlap_cb *self, int timeout) irlap_start_poll_timer() argument
184 IRDA_ASSERT(self != NULL, return;); irlap_start_poll_timer()
185 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_start_poll_timer()
192 if (skb_queue_empty(&self->txq) || self->remote_busy) { irlap_start_poll_timer()
193 if (self->fast_RR == TRUE) { irlap_start_poll_timer()
198 if (self->fast_RR_timeout < timeout) { irlap_start_poll_timer()
203 self->fast_RR_timeout += irlap_start_poll_timer()
207 timeout = self->fast_RR_timeout; irlap_start_poll_timer()
210 self->fast_RR = TRUE; irlap_start_poll_timer()
213 self->fast_RR_timeout = 0; irlap_start_poll_timer()
217 self->fast_RR = FALSE; irlap_start_poll_timer()
223 irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL); irlap_start_poll_timer()
225 irda_start_timer(&self->poll_timer, timeout, self, irlap_start_poll_timer()
235 void irlap_do_event(struct irlap_cb *self, IRLAP_EVENT event, irlap_do_event() argument
240 if (!self || self->magic != LAP_MAGIC) irlap_do_event()
244 irlap_event[event], irlap_state[self->state]); irlap_do_event()
246 ret = (*state[self->state])(self, event, skb, info); irlap_do_event()
251 switch (self->state) { irlap_do_event()
262 skb_queue_len(&self->txq)); irlap_do_event()
264 if (!skb_queue_empty(&self->txq)) { irlap_do_event()
266 self->local_busy = TRUE; irlap_do_event()
284 while ((skb = skb_dequeue(&self->txq)) != NULL) { irlap_do_event()
286 ret = (*state[self->state])(self, SEND_I_CMD, irlap_do_event()
294 irlmp_flow_indication(self->notify.instance, irlap_do_event()
301 self->local_busy = FALSE; irlap_do_event()
302 } else if (self->disconnect_pending) { irlap_do_event()
303 self->disconnect_pending = FALSE; irlap_do_event()
305 ret = (*state[self->state])(self, DISCONNECT_REQUEST, irlap_do_event()
324 static int irlap_state_ndm(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_ndm() argument
330 IRDA_ASSERT(self != NULL, return -1;); irlap_state_ndm()
331 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_ndm()
335 IRDA_ASSERT(self->netdev != NULL, return -1;); irlap_state_ndm()
337 if (self->media_busy) { irlap_state_ndm()
345 irlap_next_state(self, LAP_NDM); irlap_state_ndm()
347 irlap_disconnect_indication(self, LAP_MEDIA_BUSY); irlap_state_ndm()
349 irlap_send_snrm_frame(self, &self->qos_rx); irlap_state_ndm()
352 irlap_start_final_timer(self, self->final_timeout); irlap_state_ndm()
354 self->retry_count = 0; irlap_state_ndm()
355 irlap_next_state(self, LAP_SETUP); irlap_state_ndm()
361 self->daddr = info->daddr; irlap_state_ndm()
362 self->caddr = info->caddr; irlap_state_ndm()
364 irlap_next_state(self, LAP_CONN); irlap_state_ndm()
366 irlap_connect_indication(self, skb); irlap_state_ndm()
375 if (self->media_busy) { irlap_state_ndm()
381 irlap_discovery_confirm(self, NULL); irlap_state_ndm()
388 self->S = info->S; irlap_state_ndm()
389 self->s = info->s; irlap_state_ndm()
390 irlap_send_discovery_xid_frame(self, info->S, info->s, TRUE, irlap_state_ndm()
392 self->frame_sent = FALSE; irlap_state_ndm()
393 self->s++; irlap_state_ndm()
395 irlap_start_slot_timer(self, self->slot_timeout); irlap_state_ndm()
396 irlap_next_state(self, LAP_QUERY); irlap_state_ndm()
403 self->slot = irlap_generate_rand_time_slot(info->S, irlap_state_ndm()
405 if (self->slot == info->s) { irlap_state_ndm()
409 irlap_send_discovery_xid_frame(self, info->S, irlap_state_ndm()
410 self->slot, irlap_state_ndm()
413 self->frame_sent = TRUE; irlap_state_ndm()
415 self->frame_sent = FALSE; irlap_state_ndm()
422 irlap_start_query_timer(self, info->S, info->s); irlap_state_ndm()
423 irlap_next_state(self, LAP_REPLY); irlap_state_ndm()
447 irlap_discovery_indication(self, info->discovery); irlap_state_ndm()
462 if (!skb_queue_empty(&self->txq_ultra)) { irlap_state_ndm()
466 ret = (*state[self->state])(self, SEND_UI_FRAME, irlap_state_ndm()
472 if (self->connect_pending) { irlap_state_ndm()
473 self->connect_pending = FALSE; irlap_state_ndm()
478 if (self->disconnect_pending) irlap_state_ndm()
479 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_ndm()
481 ret = (*state[self->state])(self, irlap_state_ndm()
484 self->disconnect_pending = FALSE; irlap_state_ndm()
503 for (i=0; ((i<2) && (self->media_busy == FALSE)); i++) { irlap_state_ndm()
504 skb = skb_dequeue(&self->txq_ultra); irlap_state_ndm()
506 irlap_send_ui_frame(self, skb, CBROADCAST, irlap_state_ndm()
515 irda_device_set_media_busy(self->netdev, TRUE); irlap_state_ndm()
525 irlap_unitdata_indication(self, skb); irlap_state_ndm()
536 irlap_send_test_frame(self, CBROADCAST, info->daddr, skb); irlap_state_ndm()
557 static int irlap_state_query(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_query() argument
562 IRDA_ASSERT(self != NULL, return -1;); irlap_state_query()
563 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_query()
573 if (!self->discovery_log) { irlap_state_query()
578 hashbin_insert(self->discovery_log, irlap_state_query()
583 /* irlap_next_state(self, LAP_QUERY); */ irlap_state_query()
605 irlap_discovery_indication(self, info->discovery); irlap_state_query()
614 if (irda_device_is_receiving(self->netdev) && !self->add_wait) { irlap_state_query()
617 irlap_start_slot_timer(self, msecs_to_jiffies(10)); irlap_state_query()
618 self->add_wait = TRUE; irlap_state_query()
621 self->add_wait = FALSE; irlap_state_query()
623 if (self->s < self->S) { irlap_state_query()
624 irlap_send_discovery_xid_frame(self, self->S, irlap_state_query()
625 self->s, TRUE, irlap_state_query()
626 self->discovery_cmd); irlap_state_query()
627 self->s++; irlap_state_query()
628 irlap_start_slot_timer(self, self->slot_timeout); irlap_state_query()
631 irlap_next_state(self, LAP_QUERY); irlap_state_query()
634 irlap_send_discovery_xid_frame(self, self->S, 0xff, irlap_state_query()
636 self->discovery_cmd); irlap_state_query()
639 irlap_next_state(self, LAP_NDM); irlap_state_query()
645 irlap_discovery_confirm(self, self->discovery_log); irlap_state_query()
648 self->discovery_log = NULL; irlap_state_query()
662 * Function irlap_state_reply (self, event, skb, info)
668 static int irlap_state_reply(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_reply() argument
674 IRDA_ASSERT(self != NULL, return -1;); irlap_state_reply()
675 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_reply()
681 irlap_next_state(self, LAP_NDM); irlap_state_reply()
687 del_timer(&self->query_timer); irlap_state_reply()
692 irlap_next_state(self, LAP_NDM); irlap_state_reply()
694 irlap_discovery_indication(self, info->discovery); irlap_state_reply()
697 if ((info->s >= self->slot) && (!self->frame_sent)) { irlap_state_reply()
701 irlap_send_discovery_xid_frame(self, info->S, irlap_state_reply()
702 self->slot, irlap_state_reply()
706 self->frame_sent = TRUE; irlap_state_reply()
711 irlap_start_query_timer(self, info->S, info->s); irlap_state_reply()
714 //irlap_next_state(self, LAP_REPLY); irlap_state_reply()
734 static int irlap_state_conn(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_conn() argument
741 IRDA_ASSERT(self != NULL, return -1;); irlap_state_conn()
742 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_conn()
748 IRDA_ASSERT(self->netdev != NULL, return -1;); irlap_state_conn()
750 irlap_qos_negotiate(self, skb); irlap_state_conn()
752 irlap_initiate_connection_state(self); irlap_state_conn()
758 irlap_apply_connection_parameters(self, FALSE); irlap_state_conn()
764 irlap_send_ua_response_frame(self, &self->qos_rx); irlap_state_conn()
786 irlap_send_ua_response_frame(self, &self->qos_rx); irlap_state_conn()
794 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_conn()
795 irlap_next_state(self, LAP_NRM_S); irlap_state_conn()
801 irlap_next_state(self, LAP_NDM); irlap_state_conn()
806 irlap_send_dm_frame(self); irlap_state_conn()
807 irlap_next_state( self, LAP_NDM); irlap_state_conn()
808 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_conn()
828 static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_setup() argument
833 IRDA_ASSERT(self != NULL, return -1;); irlap_state_setup()
834 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_setup()
838 if (self->retry_count < self->N3) { irlap_state_setup()
845 irlap_start_backoff_timer(self, msecs_to_jiffies(20 + irlap_state_setup()
849 irlap_next_state(self, LAP_NDM); irlap_state_setup()
851 irlap_disconnect_indication(self, LAP_FOUND_NONE); irlap_state_setup()
855 irlap_send_snrm_frame(self, &self->qos_rx); irlap_state_setup()
856 irlap_start_final_timer(self, self->final_timeout); irlap_state_setup()
857 self->retry_count++; irlap_state_setup()
869 if (info &&(info->daddr > self->saddr)) { irlap_state_setup()
870 del_timer(&self->final_timer); irlap_state_setup()
871 irlap_initiate_connection_state(self); irlap_state_setup()
873 IRDA_ASSERT(self->netdev != NULL, return -1;); irlap_state_setup()
877 irlap_qos_negotiate(self, skb); irlap_state_setup()
880 irlap_apply_connection_parameters(self, FALSE); irlap_state_setup()
881 irlap_send_ua_response_frame(self, &self->qos_rx); irlap_state_setup()
883 irlap_next_state(self, LAP_NRM_S); irlap_state_setup()
884 irlap_connect_confirm(self, skb); irlap_state_setup()
891 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_setup()
894 irlap_next_state(self, LAP_SETUP); irlap_state_setup()
899 del_timer(&self->final_timer); irlap_state_setup()
902 irlap_initiate_connection_state(self); irlap_state_setup()
909 IRDA_ASSERT(self->netdev != NULL, return -1;); irlap_state_setup()
911 irlap_qos_negotiate(self, skb); irlap_state_setup()
914 irlap_apply_connection_parameters(self, TRUE); irlap_state_setup()
915 self->retry_count = 0; irlap_state_setup()
923 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_setup()
926 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_setup()
934 irlap_start_final_timer(self, self->final_timeout/2); irlap_state_setup()
935 irlap_next_state(self, LAP_NRM_P); irlap_state_setup()
937 irlap_connect_confirm(self, skb); irlap_state_setup()
941 del_timer(&self->final_timer); irlap_state_setup()
942 irlap_next_state(self, LAP_NDM); irlap_state_setup()
944 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_setup()
957 * Function irlap_state_offline (self, event, skb, info)
962 static int irlap_state_offline(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_offline() argument
971 * Function irlap_state_xmit_p (self, event, skb, info)
978 static int irlap_state_xmit_p(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_xmit_p() argument
988 if ((self->window > 0) && (!self->remote_busy)) { irlap_state_xmit_p()
1005 skb_next = skb_peek(&self->txq); irlap_state_xmit_p()
1018 self->bytes_left)); irlap_state_xmit_p()
1027 if((!nextfit) && (skb->len > self->bytes_left)) { irlap_state_xmit_p()
1031 skb_queue_head(&self->txq, skb_get(skb)); irlap_state_xmit_p()
1051 self->bytes_left -= skb->len; irlap_state_xmit_p()
1055 nextfit = !skb_queue_empty(&self->txq); irlap_state_xmit_p()
1061 if ((self->window > 1) && (nextfit)) { irlap_state_xmit_p()
1063 irlap_send_data_primary(self, skb); irlap_state_xmit_p()
1064 irlap_next_state(self, LAP_XMIT_P); irlap_state_xmit_p()
1067 irlap_send_data_primary_poll(self, skb); irlap_state_xmit_p()
1077 self->fast_RR = FALSE; irlap_state_xmit_p()
1082 skb_queue_head(&self->txq, skb_get(skb)); irlap_state_xmit_p()
1094 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_xmit_p()
1096 self->window = self->window_size; irlap_state_xmit_p()
1099 self->bytes_left = self->line_capacity; irlap_state_xmit_p()
1101 irlap_start_final_timer(self, self->final_timeout); irlap_state_xmit_p()
1102 irlap_next_state(self, LAP_NRM_P); irlap_state_xmit_p()
1105 del_timer(&self->poll_timer); irlap_state_xmit_p()
1106 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_xmit_p()
1107 irlap_send_disc_frame(self); irlap_state_xmit_p()
1108 irlap_flush_all_queues(self); irlap_state_xmit_p()
1109 irlap_start_final_timer(self, self->final_timeout); irlap_state_xmit_p()
1110 self->retry_count = 0; irlap_state_xmit_p()
1111 irlap_next_state(self, LAP_PCLOSE); irlap_state_xmit_p()
1132 static int irlap_state_pclose(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_pclose() argument
1137 IRDA_ASSERT(self != NULL, return -1;); irlap_state_pclose()
1138 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_pclose()
1143 del_timer(&self->final_timer); irlap_state_pclose()
1146 irlap_apply_default_connection_parameters(self); irlap_state_pclose()
1149 irlap_next_state(self, LAP_NDM); irlap_state_pclose()
1151 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_pclose()
1154 if (self->retry_count < self->N3) { irlap_state_pclose()
1155 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_pclose()
1156 irlap_send_disc_frame(self); irlap_state_pclose()
1157 irlap_start_final_timer(self, self->final_timeout); irlap_state_pclose()
1158 self->retry_count++; irlap_state_pclose()
1161 irlap_apply_default_connection_parameters(self); irlap_state_pclose()
1164 irlap_next_state(self, LAP_NDM); irlap_state_pclose()
1166 irlap_disconnect_indication(self, LAP_NO_RESPONSE); irlap_state_pclose()
1179 * Function irlap_state_nrm_p (self, event, skb, info)
1187 static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_nrm_p() argument
1204 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1205 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_nrm_p()
1216 self->fast_RR = FALSE; irlap_state_nrm_p()
1220 ns_status = irlap_validate_ns_received(self, info->ns); irlap_state_nrm_p()
1221 nr_status = irlap_validate_nr_received(self, info->nr); irlap_state_nrm_p()
1229 self->vr = (self->vr + 1) % 8; irlap_state_nrm_p()
1232 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1239 self->retry_count = 0; irlap_state_nrm_p()
1240 self->ack_required = TRUE; irlap_state_nrm_p()
1245 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1247 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_p()
1250 del_timer(&self->final_timer); irlap_state_nrm_p()
1252 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1258 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_p()
1268 irlap_next_state(self, LAP_XMIT_P); irlap_state_nrm_p()
1273 irlap_start_poll_timer(self, self->poll_timeout); irlap_state_nrm_p()
1282 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1290 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1296 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1298 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1299 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_nrm_p()
1301 self->ack_required = FALSE; irlap_state_nrm_p()
1303 irlap_start_final_timer(self, self->final_timeout); irlap_state_nrm_p()
1304 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1314 self->vr = (self->vr + 1) % 8; irlap_state_nrm_p()
1317 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1320 irlap_resend_rejected_frames(self, CMD_FRAME); irlap_state_nrm_p()
1322 self->ack_required = FALSE; irlap_state_nrm_p()
1328 irlap_start_final_timer(self, 2 * self->final_timeout); irlap_state_nrm_p()
1331 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1333 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_p()
1341 self->vr = (self->vr + 1) % 8; irlap_state_nrm_p()
1344 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1346 self->ack_required = FALSE; irlap_state_nrm_p()
1349 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1351 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_p()
1366 irlap_resend_rejected_frames(self, CMD_FRAME); irlap_state_nrm_p()
1370 irlap_start_final_timer(self, 2 * self->final_timeout); irlap_state_nrm_p()
1373 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1378 self->ack_required = FALSE; irlap_state_nrm_p()
1388 del_timer(&self->final_timer); irlap_state_nrm_p()
1390 irlap_next_state(self, LAP_RESET_WAIT); irlap_state_nrm_p()
1392 irlap_disconnect_indication(self, LAP_RESET_INDICATION); irlap_state_nrm_p()
1393 self->xmitflag = TRUE; irlap_state_nrm_p()
1395 del_timer(&self->final_timer); irlap_state_nrm_p()
1397 irlap_disconnect_indication(self, LAP_RESET_INDICATION); irlap_state_nrm_p()
1399 self->xmitflag = FALSE; irlap_state_nrm_p()
1410 irlap_data_indication(self, skb, TRUE); irlap_state_nrm_p()
1411 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1413 del_timer(&self->final_timer); irlap_state_nrm_p()
1414 irlap_data_indication(self, skb, TRUE); irlap_state_nrm_p()
1415 irlap_next_state(self, LAP_XMIT_P); irlap_state_nrm_p()
1417 __func__, irlap_state[self->state]); irlap_state_nrm_p()
1418 irlap_start_poll_timer(self, self->poll_timeout); irlap_state_nrm_p()
1426 self->remote_busy = FALSE; irlap_state_nrm_p()
1429 del_timer(&self->final_timer); irlap_state_nrm_p()
1434 ret = irlap_validate_nr_received(self, info->nr); irlap_state_nrm_p()
1437 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1444 self->retry_count = 0; irlap_state_nrm_p()
1445 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1447 irlap_next_state(self, LAP_XMIT_P); irlap_state_nrm_p()
1450 irlap_start_poll_timer(self, self->poll_timeout); irlap_state_nrm_p()
1458 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1461 self->retry_count, info->nr, self->va, irlap_state_nrm_p()
1462 self->vs, self->vr); irlap_state_nrm_p()
1465 irlap_resend_rejected_frames(self, CMD_FRAME); irlap_state_nrm_p()
1466 irlap_start_final_timer(self, self->final_timeout * 2); irlap_state_nrm_p()
1468 irlap_next_state(self, LAP_NRM_P); irlap_state_nrm_p()
1473 irlap_next_state(self, LAP_RESET_WAIT); irlap_state_nrm_p()
1475 irlap_disconnect_indication(self, LAP_RESET_INDICATION); irlap_state_nrm_p()
1476 self->xmitflag = TRUE; irlap_state_nrm_p()
1483 del_timer(&self->final_timer); irlap_state_nrm_p()
1484 self->remote_busy = TRUE; irlap_state_nrm_p()
1487 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1488 irlap_next_state(self, LAP_XMIT_P); irlap_state_nrm_p()
1491 irlap_start_poll_timer(self, self->poll_timeout); irlap_state_nrm_p()
1494 del_timer(&self->final_timer); irlap_state_nrm_p()
1495 self->xmitflag = TRUE; irlap_state_nrm_p()
1496 irlap_next_state(self, LAP_RESET_WAIT); irlap_state_nrm_p()
1497 irlap_reset_indication(self); irlap_state_nrm_p()
1506 if (irda_device_is_receiving(self->netdev) && !self->add_wait) { irlap_state_nrm_p()
1508 irlap_start_final_timer(self, msecs_to_jiffies(300)); irlap_state_nrm_p()
1515 self->add_wait = TRUE; irlap_state_nrm_p()
1518 self->add_wait = FALSE; irlap_state_nrm_p()
1521 if (self->retry_count < self->N2) { irlap_state_nrm_p()
1522 if (skb_peek(&self->wx_list) == NULL) { irlap_state_nrm_p()
1525 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1526 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_nrm_p()
1529 irlap_resend_rejected_frames(self, CMD_FRAME); irlap_state_nrm_p()
1532 irlap_start_final_timer(self, self->final_timeout); irlap_state_nrm_p()
1533 self->retry_count++; irlap_state_nrm_p()
1535 self->retry_count); irlap_state_nrm_p()
1543 if((self->retry_count % self->N1) == 0) irlap_state_nrm_p()
1544 irlap_status_indication(self, irlap_state_nrm_p()
1549 irlap_apply_default_connection_parameters(self); irlap_state_nrm_p()
1552 irlap_next_state(self, LAP_NDM); irlap_state_nrm_p()
1553 irlap_disconnect_indication(self, LAP_NO_RESPONSE); irlap_state_nrm_p()
1557 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1558 if (self->remote_busy) { irlap_state_nrm_p()
1559 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1560 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_nrm_p()
1562 irlap_resend_rejected_frames(self, CMD_FRAME); irlap_state_nrm_p()
1563 irlap_start_final_timer(self, 2 * self->final_timeout); irlap_state_nrm_p()
1566 irlap_update_nr_received(self, info->nr); irlap_state_nrm_p()
1567 if (self->remote_busy) { irlap_state_nrm_p()
1568 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_p()
1569 irlap_send_rr_frame(self, CMD_FRAME); irlap_state_nrm_p()
1571 irlap_resend_rejected_frame(self, CMD_FRAME); irlap_state_nrm_p()
1572 irlap_start_final_timer(self, 2 * self->final_timeout); irlap_state_nrm_p()
1577 irlap_flush_all_queues(self); irlap_state_nrm_p()
1578 irlap_next_state(self, LAP_XMIT_P); irlap_state_nrm_p()
1580 irlap_disconnect_request(self); irlap_state_nrm_p()
1599 static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_reset_wait() argument
1606 IRDA_ASSERT(self != NULL, return -1;); irlap_state_reset_wait()
1607 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_reset_wait()
1611 if (self->xmitflag) { irlap_state_reset_wait()
1612 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_reset_wait()
1613 irlap_send_snrm_frame(self, NULL); irlap_state_reset_wait()
1614 irlap_start_final_timer(self, self->final_timeout); irlap_state_reset_wait()
1615 irlap_next_state(self, LAP_RESET); irlap_state_reset_wait()
1617 irlap_start_final_timer(self, self->final_timeout); irlap_state_reset_wait()
1618 irlap_next_state(self, LAP_RESET); irlap_state_reset_wait()
1622 irlap_wait_min_turn_around( self, &self->qos_tx); irlap_state_reset_wait()
1623 irlap_send_disc_frame( self); irlap_state_reset_wait()
1624 irlap_flush_all_queues( self); irlap_state_reset_wait()
1625 irlap_start_final_timer( self, self->final_timeout); irlap_state_reset_wait()
1626 self->retry_count = 0; irlap_state_reset_wait()
1627 irlap_next_state( self, LAP_PCLOSE); irlap_state_reset_wait()
1640 * Function irlap_state_reset (self, event, skb, info)
1646 static int irlap_state_reset(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_reset() argument
1653 IRDA_ASSERT(self != NULL, return -1;); irlap_state_reset()
1654 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_reset()
1658 del_timer(&self->final_timer); irlap_state_reset()
1660 irlap_apply_default_connection_parameters(self); irlap_state_reset()
1663 irlap_next_state(self, LAP_NDM); irlap_state_reset()
1665 irlap_disconnect_indication(self, LAP_NO_RESPONSE); irlap_state_reset()
1669 del_timer(&self->final_timer); irlap_state_reset()
1672 irlap_initiate_connection_state(self); irlap_state_reset()
1676 self->remote_busy = FALSE; irlap_state_reset()
1678 irlap_next_state(self, LAP_XMIT_P); irlap_state_reset()
1680 irlap_start_poll_timer(self, self->poll_timeout); irlap_state_reset()
1684 if (self->retry_count < 3) { irlap_state_reset()
1685 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_reset()
1687 IRDA_ASSERT(self->netdev != NULL, return -1;); irlap_state_reset()
1688 irlap_send_snrm_frame(self, self->qos_dev); irlap_state_reset()
1690 self->retry_count++; /* Experimental!! */ irlap_state_reset()
1692 irlap_start_final_timer(self, self->final_timeout); irlap_state_reset()
1693 irlap_next_state(self, LAP_RESET); irlap_state_reset()
1694 } else if (self->retry_count >= self->N3) { irlap_state_reset()
1695 irlap_apply_default_connection_parameters(self); irlap_state_reset()
1698 irlap_next_state(self, LAP_NDM); irlap_state_reset()
1700 irlap_disconnect_indication(self, LAP_NO_RESPONSE); irlap_state_reset()
1710 irlap_initiate_connection_state(self); irlap_state_reset()
1711 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_reset()
1712 irlap_send_ua_response_frame(self, &self->qos_rx); irlap_state_reset()
1714 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_reset()
1715 irlap_next_state(self, LAP_NDM); irlap_state_reset()
1738 static int irlap_state_xmit_s(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_xmit_s() argument
1745 IRDA_ASSERT(self != NULL, return -ENODEV;); irlap_state_xmit_s()
1746 IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;); irlap_state_xmit_s()
1753 if ((self->window > 0) && (!self->remote_busy)) { irlap_state_xmit_s()
1768 skb_next = skb_peek(&self->txq); irlap_state_xmit_s()
1771 self->bytes_left)); irlap_state_xmit_s()
1778 if((!nextfit) && (skb->len > self->bytes_left)) { irlap_state_xmit_s()
1782 skb_queue_head(&self->txq, skb_get(skb)); irlap_state_xmit_s()
1790 self->window = self->window_size; irlap_state_xmit_s()
1791 self->bytes_left = self->line_capacity; irlap_state_xmit_s()
1792 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_xmit_s()
1794 irlap_next_state(self, LAP_NRM_S); irlap_state_xmit_s()
1802 self->bytes_left -= skb->len; irlap_state_xmit_s()
1806 nextfit = !skb_queue_empty(&self->txq); irlap_state_xmit_s()
1812 if ((self->window > 1) && (nextfit)) { irlap_state_xmit_s()
1813 irlap_send_data_secondary(self, skb); irlap_state_xmit_s()
1814 irlap_next_state(self, LAP_XMIT_S); irlap_state_xmit_s()
1816 irlap_send_data_secondary_final(self, skb); irlap_state_xmit_s()
1817 irlap_next_state(self, LAP_NRM_S); irlap_state_xmit_s()
1827 skb_queue_head(&self->txq, skb_get(skb)); irlap_state_xmit_s()
1832 irlap_send_rd_frame(self); irlap_state_xmit_s()
1833 irlap_flush_all_queues(self); irlap_state_xmit_s()
1834 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_xmit_s()
1835 irlap_next_state(self, LAP_SCLOSE); irlap_state_xmit_s()
1858 static int irlap_state_nrm_s(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_nrm_s() argument
1867 IRDA_ASSERT(self != NULL, return -1;); irlap_state_nrm_s()
1868 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_state_nrm_s()
1875 self->vs, info->ns, self->vr, info->pf); irlap_state_nrm_s()
1877 self->retry_count = 0; irlap_state_nrm_s()
1879 ns_status = irlap_validate_ns_received(self, info->ns); irlap_state_nrm_s()
1880 nr_status = irlap_validate_nr_received(self, info->nr); irlap_state_nrm_s()
1887 self->vr = (self->vr + 1) % 8; irlap_state_nrm_s()
1890 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
1897 self->ack_required = TRUE; irlap_state_nrm_s()
1904 irda_start_timer(WD_TIMER, self->wd_timeout); irlap_state_nrm_s()
1907 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
1909 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_s()
1917 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
1925 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_s()
1928 if (!skb_queue_empty(&self->txq) && irlap_state_nrm_s()
1929 (self->window > 0)) irlap_state_nrm_s()
1931 self->ack_required = TRUE; irlap_state_nrm_s()
1933 del_timer(&self->wd_timer); irlap_state_nrm_s()
1935 irlap_next_state(self, LAP_XMIT_S); irlap_state_nrm_s()
1937 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
1938 irlap_start_wd_timer(self, irlap_state_nrm_s()
1939 self->wd_timeout); irlap_state_nrm_s()
1942 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
1954 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
1956 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
1959 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
1961 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
1962 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
1964 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
1977 self->vr = (self->vr + 1) % 8; irlap_state_nrm_s()
1980 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
1983 irlap_resend_rejected_frames(self, RSP_FRAME); irlap_state_nrm_s()
1986 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
1988 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_s()
1989 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
1997 self->vr = (self->vr + 1) % 8; irlap_state_nrm_s()
2000 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
2003 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
2005 irlap_data_indication(self, skb, FALSE); irlap_state_nrm_s()
2006 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2023 irlap_data_indication(self, skb, TRUE); irlap_state_nrm_s()
2024 irlap_next_state(self, LAP_NRM_S); /* Keep state */ irlap_state_nrm_s()
2029 if (!skb_queue_empty(&self->txq) && irlap_state_nrm_s()
2030 (self->window > 0) && !self->remote_busy) irlap_state_nrm_s()
2032 irlap_data_indication(self, skb, TRUE); irlap_state_nrm_s()
2034 del_timer(&self->wd_timer); irlap_state_nrm_s()
2036 irlap_next_state(self, LAP_XMIT_S); irlap_state_nrm_s()
2038 irlap_data_indication(self, skb, TRUE); irlap_state_nrm_s()
2040 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2042 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
2043 self->ack_required = FALSE; irlap_state_nrm_s()
2045 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2048 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
2053 self->retry_count = 0; irlap_state_nrm_s()
2058 nr_status = irlap_validate_nr_received(self, info->nr); irlap_state_nrm_s()
2060 if (!skb_queue_empty(&self->txq) && irlap_state_nrm_s()
2061 (self->window > 0)) { irlap_state_nrm_s()
2062 self->remote_busy = FALSE; irlap_state_nrm_s()
2065 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
2066 del_timer(&self->wd_timer); irlap_state_nrm_s()
2068 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2069 irlap_next_state(self, LAP_XMIT_S); irlap_state_nrm_s()
2071 self->remote_busy = FALSE; irlap_state_nrm_s()
2073 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
2074 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2075 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2081 if (self->disconnect_pending) { irlap_state_nrm_s()
2083 irlap_send_rd_frame(self); irlap_state_nrm_s()
2084 irlap_flush_all_queues(self); irlap_state_nrm_s()
2086 irlap_next_state(self, LAP_SCLOSE); irlap_state_nrm_s()
2089 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
2091 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
2095 self->remote_busy = FALSE; irlap_state_nrm_s()
2096 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
2097 irlap_resend_rejected_frames(self, RSP_FRAME); irlap_state_nrm_s()
2099 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2102 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
2111 del_timer(&self->wd_timer); irlap_state_nrm_s()
2113 irlap_next_state(self, LAP_RESET_CHECK); irlap_state_nrm_s()
2115 irlap_reset_indication(self); irlap_state_nrm_s()
2123 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
2124 if (self->remote_busy) { irlap_state_nrm_s()
2125 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2126 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
2128 irlap_resend_rejected_frames(self, RSP_FRAME); irlap_state_nrm_s()
2129 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2132 irlap_update_nr_received(self, info->nr); irlap_state_nrm_s()
2133 if (self->remote_busy) { irlap_state_nrm_s()
2134 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2135 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
2137 irlap_resend_rejected_frame(self, RSP_FRAME); irlap_state_nrm_s()
2138 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2146 * Note : self->wd_timeout = (self->final_timeout * 2), irlap_state_nrm_s()
2147 * which explain why we use (self->N2 / 2) here !!! irlap_state_nrm_s()
2151 self->retry_count); irlap_state_nrm_s()
2153 if (self->retry_count < (self->N2 / 2)) { irlap_state_nrm_s()
2155 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2156 self->retry_count++; irlap_state_nrm_s()
2158 if((self->retry_count % (self->N1 / 2)) == 0) irlap_state_nrm_s()
2159 irlap_status_indication(self, irlap_state_nrm_s()
2162 irlap_apply_default_connection_parameters(self); irlap_state_nrm_s()
2165 irlap_next_state(self, LAP_NDM); irlap_state_nrm_s()
2166 irlap_disconnect_indication(self, LAP_NO_RESPONSE); irlap_state_nrm_s()
2171 irlap_next_state(self, LAP_NDM); irlap_state_nrm_s()
2174 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2175 irlap_send_ua_response_frame(self, NULL); irlap_state_nrm_s()
2177 del_timer(&self->wd_timer); irlap_state_nrm_s()
2178 irlap_flush_all_queues(self); irlap_state_nrm_s()
2180 irlap_apply_default_connection_parameters(self); irlap_state_nrm_s()
2182 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_nrm_s()
2185 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2186 irlap_send_rr_frame(self, RSP_FRAME); irlap_state_nrm_s()
2187 self->ack_required = TRUE; irlap_state_nrm_s()
2188 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2189 irlap_next_state(self, LAP_NRM_S); irlap_state_nrm_s()
2196 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_nrm_s()
2197 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_nrm_s()
2200 irlap_send_test_frame(self, self->caddr, info->daddr, skb); irlap_state_nrm_s()
2213 * Function irlap_state_sclose (self, event, skb, info)
2215 static int irlap_state_sclose(struct irlap_cb *self, IRLAP_EVENT event, irlap_state_sclose() argument
2218 IRDA_ASSERT(self != NULL, return -ENODEV;); irlap_state_sclose()
2219 IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;); irlap_state_sclose()
2224 irlap_next_state(self, LAP_NDM); irlap_state_sclose()
2227 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_sclose()
2228 irlap_send_ua_response_frame(self, NULL); irlap_state_sclose()
2230 del_timer(&self->wd_timer); irlap_state_sclose()
2232 irlap_apply_default_connection_parameters(self); irlap_state_sclose()
2234 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_sclose()
2246 irlap_next_state(self, LAP_NDM); irlap_state_sclose()
2248 del_timer(&self->wd_timer); irlap_state_sclose()
2249 irlap_apply_default_connection_parameters(self); irlap_state_sclose()
2251 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_sclose()
2255 irlap_next_state(self, LAP_NDM); irlap_state_sclose()
2257 irlap_apply_default_connection_parameters(self); irlap_state_sclose()
2259 irlap_disconnect_indication(self, LAP_DISC_INDICATION); irlap_state_sclose()
2266 del_timer(&self->wd_timer); irlap_state_sclose()
2267 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_sclose()
2268 irlap_send_rd_frame(self); irlap_state_sclose()
2269 irlap_start_wd_timer(self, self->wd_timeout); irlap_state_sclose()
2282 static int irlap_state_reset_check( struct irlap_cb *self, IRLAP_EVENT event, irlap_state_reset_check() argument
2290 IRDA_ASSERT(self != NULL, return -ENODEV;); irlap_state_reset_check()
2291 IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;); irlap_state_reset_check()
2295 irlap_send_ua_response_frame(self, &self->qos_rx); irlap_state_reset_check()
2296 irlap_initiate_connection_state(self); irlap_state_reset_check()
2297 irlap_start_wd_timer(self, WD_TIMEOUT); irlap_state_reset_check()
2298 irlap_flush_all_queues(self); irlap_state_reset_check()
2300 irlap_next_state(self, LAP_NRM_S); irlap_state_reset_check()
2303 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_state_reset_check()
2304 irlap_send_rd_frame(self); irlap_state_reset_check()
2305 irlap_start_wd_timer(self, WD_TIMEOUT); irlap_state_reset_check()
2306 irlap_next_state(self, LAP_SCLOSE); irlap_state_reset_check()
|
| H A D | iriap_event.c | 34 static void state_s_disconnect (struct iriap_cb *self, IRIAP_EVENT event,
36 static void state_s_connecting (struct iriap_cb *self, IRIAP_EVENT event,
38 static void state_s_call (struct iriap_cb *self, IRIAP_EVENT event,
41 static void state_s_make_call (struct iriap_cb *self, IRIAP_EVENT event,
43 static void state_s_calling (struct iriap_cb *self, IRIAP_EVENT event,
45 static void state_s_outstanding (struct iriap_cb *self, IRIAP_EVENT event,
47 static void state_s_replying (struct iriap_cb *self, IRIAP_EVENT event,
49 static void state_s_wait_for_call(struct iriap_cb *self, IRIAP_EVENT event,
51 static void state_s_wait_active (struct iriap_cb *self, IRIAP_EVENT event,
54 static void state_r_disconnect (struct iriap_cb *self, IRIAP_EVENT event,
56 static void state_r_call (struct iriap_cb *self, IRIAP_EVENT event,
58 static void state_r_waiting (struct iriap_cb *self, IRIAP_EVENT event,
60 static void state_r_wait_active (struct iriap_cb *self, IRIAP_EVENT event,
62 static void state_r_receiving (struct iriap_cb *self, IRIAP_EVENT event,
64 static void state_r_execute (struct iriap_cb *self, IRIAP_EVENT event,
66 static void state_r_returning (struct iriap_cb *self, IRIAP_EVENT event,
69 static void (*iriap_state[])(struct iriap_cb *self, IRIAP_EVENT event,
96 void iriap_next_client_state(struct iriap_cb *self, IRIAP_STATE state) iriap_next_client_state() argument
98 IRDA_ASSERT(self != NULL, return;); iriap_next_client_state()
99 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_next_client_state()
101 self->client_state = state; iriap_next_client_state()
104 void iriap_next_call_state(struct iriap_cb *self, IRIAP_STATE state) iriap_next_call_state() argument
106 IRDA_ASSERT(self != NULL, return;); iriap_next_call_state()
107 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_next_call_state()
109 self->call_state = state; iriap_next_call_state()
112 void iriap_next_server_state(struct iriap_cb *self, IRIAP_STATE state) iriap_next_server_state() argument
114 IRDA_ASSERT(self != NULL, return;); iriap_next_server_state()
115 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_next_server_state()
117 self->server_state = state; iriap_next_server_state()
120 void iriap_next_r_connect_state(struct iriap_cb *self, IRIAP_STATE state) iriap_next_r_connect_state() argument
122 IRDA_ASSERT(self != NULL, return;); iriap_next_r_connect_state()
123 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_next_r_connect_state()
125 self->r_connect_state = state; iriap_next_r_connect_state()
128 void iriap_do_client_event(struct iriap_cb *self, IRIAP_EVENT event, iriap_do_client_event() argument
131 IRDA_ASSERT(self != NULL, return;); iriap_do_client_event()
132 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_do_client_event()
134 (*iriap_state[ self->client_state]) (self, event, skb); iriap_do_client_event()
137 void iriap_do_call_event(struct iriap_cb *self, IRIAP_EVENT event, iriap_do_call_event() argument
140 IRDA_ASSERT(self != NULL, return;); iriap_do_call_event()
141 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_do_call_event()
143 (*iriap_state[ self->call_state]) (self, event, skb); iriap_do_call_event()
146 void iriap_do_server_event(struct iriap_cb *self, IRIAP_EVENT event, iriap_do_server_event() argument
149 IRDA_ASSERT(self != NULL, return;); iriap_do_server_event()
150 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_do_server_event()
152 (*iriap_state[ self->server_state]) (self, event, skb); iriap_do_server_event()
155 void iriap_do_r_connect_event(struct iriap_cb *self, IRIAP_EVENT event, iriap_do_r_connect_event() argument
158 IRDA_ASSERT(self != NULL, return;); iriap_do_r_connect_event()
159 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_do_r_connect_event()
161 (*iriap_state[ self->r_connect_state]) (self, event, skb); iriap_do_r_connect_event()
171 static void state_s_disconnect(struct iriap_cb *self, IRIAP_EVENT event, state_s_disconnect() argument
174 IRDA_ASSERT(self != NULL, return;); state_s_disconnect()
175 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); state_s_disconnect()
179 iriap_next_client_state(self, S_CONNECTING); state_s_disconnect()
180 IRDA_ASSERT(self->request_skb == NULL, return;); state_s_disconnect()
184 self->request_skb = skb; state_s_disconnect()
185 iriap_connect_request(self); state_s_disconnect()
196 * Function state_s_connecting (self, event, skb)
201 static void state_s_connecting(struct iriap_cb *self, IRIAP_EVENT event, state_s_connecting() argument
204 IRDA_ASSERT(self != NULL, return;); state_s_connecting()
205 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); state_s_connecting()
212 iriap_do_call_event(self, IAP_CALL_REQUEST, skb); state_s_connecting()
213 /* iriap_call_request(self, 0,0,0); */ state_s_connecting()
214 iriap_next_client_state(self, S_CALL); state_s_connecting()
218 iriap_next_call_state(self, S_MAKE_CALL); state_s_connecting()
219 iriap_next_client_state(self, S_DISCONNECT); state_s_connecting()
228 * Function state_s_call (self, event, skb)
234 static void state_s_call(struct iriap_cb *self, IRIAP_EVENT event, state_s_call() argument
237 IRDA_ASSERT(self != NULL, return;); state_s_call()
242 iriap_next_call_state(self, S_MAKE_CALL); state_s_call()
243 iriap_next_client_state(self, S_DISCONNECT); state_s_call()
257 static void state_s_make_call(struct iriap_cb *self, IRIAP_EVENT event, state_s_make_call() argument
262 IRDA_ASSERT(self != NULL, return;); state_s_make_call()
267 tx_skb = self->request_skb; state_s_make_call()
268 self->request_skb = NULL; state_s_make_call()
270 irlmp_data_request(self->lsap, tx_skb); state_s_make_call()
271 iriap_next_call_state(self, S_OUTSTANDING); state_s_make_call()
285 static void state_s_calling(struct iriap_cb *self, IRIAP_EVENT event, state_s_calling() argument
297 static void state_s_outstanding(struct iriap_cb *self, IRIAP_EVENT event, state_s_outstanding() argument
300 IRDA_ASSERT(self != NULL, return;); state_s_outstanding()
304 /*iriap_send_ack(self);*/ state_s_outstanding()
307 iriap_next_call_state(self, S_WAIT_FOR_CALL); state_s_outstanding()
320 static void state_s_replying(struct iriap_cb *self, IRIAP_EVENT event, state_s_replying() argument
332 static void state_s_wait_for_call(struct iriap_cb *self, IRIAP_EVENT event, state_s_wait_for_call() argument
345 static void state_s_wait_active(struct iriap_cb *self, IRIAP_EVENT event, state_s_wait_active() argument
358 * Function state_r_disconnect (self, event, skb)
363 static void state_r_disconnect(struct iriap_cb *self, IRIAP_EVENT event, state_r_disconnect() argument
377 irlmp_connect_response(self->lsap, tx_skb); state_r_disconnect()
380 iriap_next_server_state(self, R_CALL); state_r_disconnect()
386 iriap_next_r_connect_state(self, R_RECEIVING); state_r_disconnect()
395 * Function state_r_call (self, event, skb)
397 static void state_r_call(struct iriap_cb *self, IRIAP_EVENT event, state_r_call() argument
403 iriap_next_server_state(self, R_DISCONNECT); state_r_call()
404 iriap_next_r_connect_state(self, R_WAITING); state_r_call()
417 * Function state_r_waiting (self, event, skb)
419 static void state_r_waiting(struct iriap_cb *self, IRIAP_EVENT event, state_r_waiting() argument
425 static void state_r_wait_active(struct iriap_cb *self, IRIAP_EVENT event, state_r_wait_active() argument
432 * Function state_r_receiving (self, event, skb)
437 static void state_r_receiving(struct iriap_cb *self, IRIAP_EVENT event, state_r_receiving() argument
442 iriap_next_r_connect_state(self, R_EXECUTE); state_r_receiving()
444 iriap_call_indication(self, skb); state_r_receiving()
453 * Function state_r_execute (self, event, skb)
458 static void state_r_execute(struct iriap_cb *self, IRIAP_EVENT event, state_r_execute() argument
462 IRDA_ASSERT(self != NULL, return;); state_r_execute()
463 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); state_r_execute()
471 iriap_next_r_connect_state(self, R_RECEIVING); state_r_execute()
477 irlmp_data_request(self->lsap, skb); state_r_execute()
485 static void state_r_returning(struct iriap_cb *self, IRIAP_EVENT event, state_r_returning() argument
|
| H A D | irlap.c | 58 extern void irlap_queue_xmit(struct irlap_cb *self, struct sk_buff *skb);
59 static void __irlap_close(struct irlap_cb *self);
60 static void irlap_init_qos_capabilities(struct irlap_cb *self,
110 struct irlap_cb *self; irlap_open() local
113 self = kzalloc(sizeof(struct irlap_cb), GFP_KERNEL); irlap_open()
114 if (self == NULL) irlap_open()
117 self->magic = LAP_MAGIC; irlap_open()
120 self->netdev = dev; irlap_open()
121 self->qos_dev = qos; irlap_open()
124 strlcpy(self->hw_name, hw_name, sizeof(self->hw_name)); irlap_open()
126 self->hw_name[0] = '\0'; irlap_open()
130 dev->atalk_ptr = self; irlap_open()
132 self->state = LAP_OFFLINE; irlap_open()
135 skb_queue_head_init(&self->txq); irlap_open()
136 skb_queue_head_init(&self->txq_ultra); irlap_open()
137 skb_queue_head_init(&self->wx_list); irlap_open()
145 get_random_bytes(&self->saddr, sizeof(self->saddr)); irlap_open()
146 } while ((self->saddr == 0x0) || (self->saddr == BROADCAST) || irlap_open()
147 (hashbin_lock_find(irlap, self->saddr, NULL)) ); irlap_open()
149 memcpy(dev->dev_addr, &self->saddr, 4); irlap_open()
151 init_timer(&self->slot_timer); irlap_open()
152 init_timer(&self->query_timer); irlap_open()
153 init_timer(&self->discovery_timer); irlap_open()
154 init_timer(&self->final_timer); irlap_open()
155 init_timer(&self->poll_timer); irlap_open()
156 init_timer(&self->wd_timer); irlap_open()
157 init_timer(&self->backoff_timer); irlap_open()
158 init_timer(&self->media_busy_timer); irlap_open()
160 irlap_apply_default_connection_parameters(self); irlap_open()
162 self->N3 = 3; /* # connections attempts to try before giving up */ irlap_open()
164 self->state = LAP_NDM; irlap_open()
166 hashbin_insert(irlap, (irda_queue_t *) self, self->saddr, NULL); irlap_open()
168 irlmp_register_link(self, self->saddr, &self->notify); irlap_open()
170 return self; irlap_open()
175 * Function __irlap_close (self)
180 static void __irlap_close(struct irlap_cb *self) __irlap_close() argument
182 IRDA_ASSERT(self != NULL, return;); __irlap_close()
183 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); __irlap_close()
186 del_timer(&self->slot_timer); __irlap_close()
187 del_timer(&self->query_timer); __irlap_close()
188 del_timer(&self->discovery_timer); __irlap_close()
189 del_timer(&self->final_timer); __irlap_close()
190 del_timer(&self->poll_timer); __irlap_close()
191 del_timer(&self->wd_timer); __irlap_close()
192 del_timer(&self->backoff_timer); __irlap_close()
193 del_timer(&self->media_busy_timer); __irlap_close()
195 irlap_flush_all_queues(self); __irlap_close()
197 self->magic = 0; __irlap_close()
199 kfree(self); __irlap_close()
203 * Function irlap_close (self)
208 void irlap_close(struct irlap_cb *self) irlap_close() argument
212 IRDA_ASSERT(self != NULL, return;); irlap_close()
213 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_close()
220 irlmp_unregister_link(self->saddr); irlap_close()
221 self->notify.instance = NULL; irlap_close()
224 lap = hashbin_remove(irlap, self->saddr, NULL); irlap_close()
234 * Function irlap_connect_indication (self, skb)
239 void irlap_connect_indication(struct irlap_cb *self, struct sk_buff *skb) irlap_connect_indication() argument
241 IRDA_ASSERT(self != NULL, return;); irlap_connect_indication()
242 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_connect_indication()
244 irlap_init_qos_capabilities(self, NULL); /* No user QoS! */ irlap_connect_indication()
246 irlmp_link_connect_indication(self->notify.instance, self->saddr, irlap_connect_indication()
247 self->daddr, &self->qos_tx, skb); irlap_connect_indication()
251 * Function irlap_connect_response (self, skb)
256 void irlap_connect_response(struct irlap_cb *self, struct sk_buff *userdata) irlap_connect_response() argument
258 irlap_do_event(self, CONNECT_RESPONSE, userdata, NULL); irlap_connect_response()
262 * Function irlap_connect_request (self, daddr, qos_user, sniff)
268 void irlap_connect_request(struct irlap_cb *self, __u32 daddr, irlap_connect_request() argument
273 IRDA_ASSERT(self != NULL, return;); irlap_connect_request()
274 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_connect_request()
276 self->daddr = daddr; irlap_connect_request()
282 irlap_init_qos_capabilities(self, qos_user); irlap_connect_request()
284 if ((self->state == LAP_NDM) && !self->media_busy) irlap_connect_request()
285 irlap_do_event(self, CONNECT_REQUEST, NULL, NULL); irlap_connect_request()
287 self->connect_pending = TRUE; irlap_connect_request()
291 * Function irlap_connect_confirm (self, skb)
296 void irlap_connect_confirm(struct irlap_cb *self, struct sk_buff *skb) irlap_connect_confirm() argument
298 IRDA_ASSERT(self != NULL, return;); irlap_connect_confirm()
299 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_connect_confirm()
301 irlmp_link_connect_confirm(self->notify.instance, &self->qos_tx, skb); irlap_connect_confirm()
305 * Function irlap_data_indication (self, skb)
311 void irlap_data_indication(struct irlap_cb *self, struct sk_buff *skb, irlap_data_indication() argument
317 irlmp_link_data_indication(self->notify.instance, skb, unreliable); irlap_data_indication()
322 * Function irlap_data_request (self, skb)
327 void irlap_data_request(struct irlap_cb *self, struct sk_buff *skb, irlap_data_request() argument
330 IRDA_ASSERT(self != NULL, return;); irlap_data_request()
331 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_data_request()
350 skb_queue_tail(&self->txq, skb); irlap_data_request()
356 if ((self->state == LAP_XMIT_P) || (self->state == LAP_XMIT_S)) { irlap_data_request()
359 if((skb_queue_len(&self->txq) <= 1) && (!self->local_busy)) irlap_data_request()
360 irlap_do_event(self, DATA_REQUEST, skb, NULL); irlap_data_request()
367 * Function irlap_unitdata_request (self, skb)
373 void irlap_unitdata_request(struct irlap_cb *self, struct sk_buff *skb) irlap_unitdata_request() argument
375 IRDA_ASSERT(self != NULL, return;); irlap_unitdata_request()
376 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_unitdata_request()
387 skb_queue_tail(&self->txq_ultra, skb); irlap_unitdata_request()
389 irlap_do_event(self, SEND_UI_FRAME, NULL, NULL); irlap_unitdata_request()
394 * Function irlap_udata_indication (self, skb)
400 void irlap_unitdata_indication(struct irlap_cb *self, struct sk_buff *skb) irlap_unitdata_indication() argument
402 IRDA_ASSERT(self != NULL, return;); irlap_unitdata_indication()
403 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_unitdata_indication()
409 irlmp_link_unitdata_indication(self->notify.instance, skb); irlap_unitdata_indication()
418 void irlap_disconnect_request(struct irlap_cb *self) irlap_disconnect_request() argument
420 IRDA_ASSERT(self != NULL, return;); irlap_disconnect_request()
421 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_disconnect_request()
424 if (!skb_queue_empty(&self->txq)) { irlap_disconnect_request()
425 self->disconnect_pending = TRUE; irlap_disconnect_request()
430 switch (self->state) { irlap_disconnect_request()
436 irlap_do_event(self, DISCONNECT_REQUEST, NULL, NULL); irlap_disconnect_request()
440 self->disconnect_pending = TRUE; irlap_disconnect_request()
451 void irlap_disconnect_indication(struct irlap_cb *self, LAP_REASON reason) irlap_disconnect_indication() argument
455 IRDA_ASSERT(self != NULL, return;); irlap_disconnect_indication()
456 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_disconnect_indication()
459 irlap_flush_all_queues(self); irlap_disconnect_indication()
464 irlap_do_event(self, RESET_REQUEST, NULL, NULL); irlap_disconnect_indication()
470 irlmp_link_disconnect_indication(self->notify.instance, self, irlap_disconnect_indication()
485 void irlap_discovery_request(struct irlap_cb *self, discovery_t *discovery) irlap_discovery_request() argument
489 IRDA_ASSERT(self != NULL, return;); irlap_discovery_request()
490 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_discovery_request()
500 if (self->state != LAP_NDM) { irlap_discovery_request()
503 irlap_discovery_confirm(self, NULL); irlap_discovery_request()
515 if (self->discovery_log != NULL) { irlap_discovery_request()
516 hashbin_delete(self->discovery_log, (FREE_FUNC) kfree); irlap_discovery_request()
517 self->discovery_log = NULL; irlap_discovery_request()
521 self->discovery_log = hashbin_new(HB_NOLOCK); irlap_discovery_request()
523 if (self->discovery_log == NULL) { irlap_discovery_request()
532 self->discovery_cmd = discovery; irlap_discovery_request()
536 self->slot_timeout = msecs_to_jiffies(sysctl_slot_timeout); irlap_discovery_request()
538 irlap_do_event(self, DISCOVERY_REQUEST, NULL, &info); irlap_discovery_request()
547 void irlap_discovery_confirm(struct irlap_cb *self, hashbin_t *discovery_log) irlap_discovery_confirm() argument
549 IRDA_ASSERT(self != NULL, return;); irlap_discovery_confirm()
550 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_discovery_confirm()
552 IRDA_ASSERT(self->notify.instance != NULL, return;); irlap_discovery_confirm()
566 irda_device_set_media_busy(self->netdev, FALSE); irlap_discovery_confirm()
569 irlmp_link_discovery_confirm(self->notify.instance, discovery_log); irlap_discovery_confirm()
578 void irlap_discovery_indication(struct irlap_cb *self, discovery_t *discovery) irlap_discovery_indication() argument
580 IRDA_ASSERT(self != NULL, return;); irlap_discovery_indication()
581 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_discovery_indication()
584 IRDA_ASSERT(self->notify.instance != NULL, return;); irlap_discovery_indication()
595 irda_device_set_media_busy(self->netdev, SMALL); irlap_discovery_indication()
597 irlmp_link_discovery_indication(self->notify.instance, discovery); irlap_discovery_indication()
603 void irlap_status_indication(struct irlap_cb *self, int quality_of_link) irlap_status_indication() argument
615 irlmp_status_indication(self->notify.instance, irlap_status_indication()
622 void irlap_reset_indication(struct irlap_cb *self) irlap_reset_indication() argument
624 IRDA_ASSERT(self != NULL, return;); irlap_reset_indication()
625 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_reset_indication()
627 if (self->state == LAP_RESET_WAIT) irlap_reset_indication()
628 irlap_do_event(self, RESET_REQUEST, NULL, NULL); irlap_reset_indication()
630 irlap_do_event(self, RESET_RESPONSE, NULL, NULL); irlap_reset_indication()
672 void irlap_update_nr_received(struct irlap_cb *self, int nr) irlap_update_nr_received() argument
686 if (nr == self->vs) { irlap_update_nr_received()
687 while ((skb = skb_dequeue(&self->wx_list)) != NULL) { irlap_update_nr_received()
691 self->va = nr - 1; irlap_update_nr_received()
694 while ((skb_peek(&self->wx_list) != NULL) && irlap_update_nr_received()
695 (((self->va+1) % 8) != nr)) irlap_update_nr_received()
697 skb = skb_dequeue(&self->wx_list); irlap_update_nr_received()
700 self->va = (self->va + 1) % 8; irlap_update_nr_received()
706 self->window = self->window_size - skb_queue_len(&self->wx_list); irlap_update_nr_received()
714 int irlap_validate_ns_received(struct irlap_cb *self, int ns) irlap_validate_ns_received() argument
717 if (ns == self->vr) irlap_validate_ns_received()
733 int irlap_validate_nr_received(struct irlap_cb *self, int nr) irlap_validate_nr_received() argument
736 if (nr == self->vs) { irlap_validate_nr_received()
745 if (self->va < self->vs) { irlap_validate_nr_received()
746 if ((nr >= self->va) && (nr <= self->vs)) irlap_validate_nr_received()
749 if ((nr >= self->va) || (nr <= self->vs)) irlap_validate_nr_received()
763 void irlap_initiate_connection_state(struct irlap_cb *self) irlap_initiate_connection_state() argument
765 IRDA_ASSERT(self != NULL, return;); irlap_initiate_connection_state()
766 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_initiate_connection_state()
769 self->vs = self->vr = 0; irlap_initiate_connection_state()
772 self->va = 7; irlap_initiate_connection_state()
774 self->window = 1; irlap_initiate_connection_state()
776 self->remote_busy = FALSE; irlap_initiate_connection_state()
777 self->retry_count = 0; irlap_initiate_connection_state()
781 * Function irlap_wait_min_turn_around (self, qos)
788 void irlap_wait_min_turn_around(struct irlap_cb *self, struct qos_info *qos) irlap_wait_min_turn_around() argument
799 self->mtt_required = min_turn_time; irlap_wait_min_turn_around()
808 self->xbofs_delay = irlap_min_turn_time_in_bytes(speed, min_turn_time); irlap_wait_min_turn_around()
817 void irlap_flush_all_queues(struct irlap_cb *self) irlap_flush_all_queues() argument
821 IRDA_ASSERT(self != NULL, return;); irlap_flush_all_queues()
822 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_flush_all_queues()
825 while ((skb = skb_dequeue(&self->txq)) != NULL) irlap_flush_all_queues()
828 while ((skb = skb_dequeue(&self->txq_ultra)) != NULL) irlap_flush_all_queues()
832 while ((skb = skb_dequeue(&self->wx_list)) != NULL) irlap_flush_all_queues()
837 * Function irlap_setspeed (self, speed)
842 static void irlap_change_speed(struct irlap_cb *self, __u32 speed, int now) irlap_change_speed() argument
848 IRDA_ASSERT(self != NULL, return;); irlap_change_speed()
849 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_change_speed()
851 self->speed = speed; irlap_change_speed()
858 irlap_queue_xmit(self, skb); irlap_change_speed()
863 * Function irlap_init_qos_capabilities (self, qos)
870 static void irlap_init_qos_capabilities(struct irlap_cb *self, irlap_init_qos_capabilities() argument
873 IRDA_ASSERT(self != NULL, return;); irlap_init_qos_capabilities()
874 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_init_qos_capabilities()
875 IRDA_ASSERT(self->netdev != NULL, return;); irlap_init_qos_capabilities()
878 irda_init_max_qos_capabilies(&self->qos_rx); irlap_init_qos_capabilities()
881 irda_qos_compute_intersection(&self->qos_rx, self->qos_dev); irlap_init_qos_capabilities()
892 self->qos_rx.baud_rate.bits &= qos_user->baud_rate.bits; irlap_init_qos_capabilities()
895 self->qos_rx.max_turn_time.bits &= qos_user->max_turn_time.bits; irlap_init_qos_capabilities()
897 self->qos_rx.data_size.bits &= qos_user->data_size.bits; irlap_init_qos_capabilities()
900 self->qos_rx.link_disc_time.bits &= qos_user->link_disc_time.bits; irlap_init_qos_capabilities()
904 self->qos_rx.max_turn_time.bits &= 0x01; irlap_init_qos_capabilities()
907 /*self->qos_rx.data_size.bits &= 0x03;*/ irlap_init_qos_capabilities()
909 irda_qos_bits_to_value(&self->qos_rx); irlap_init_qos_capabilities()
917 void irlap_apply_default_connection_parameters(struct irlap_cb *self) irlap_apply_default_connection_parameters() argument
919 IRDA_ASSERT(self != NULL, return;); irlap_apply_default_connection_parameters()
920 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_apply_default_connection_parameters()
923 self->next_bofs = 12; irlap_apply_default_connection_parameters()
924 self->bofs_count = 12; irlap_apply_default_connection_parameters()
927 irlap_change_speed(self, 9600, TRUE); irlap_apply_default_connection_parameters()
930 irda_device_set_media_busy(self->netdev, TRUE); irlap_apply_default_connection_parameters()
936 while ((self->caddr == 0x00) || (self->caddr == 0xfe)) { irlap_apply_default_connection_parameters()
937 get_random_bytes(&self->caddr, sizeof(self->caddr)); irlap_apply_default_connection_parameters()
938 self->caddr &= 0xfe; irlap_apply_default_connection_parameters()
942 self->slot_timeout = sysctl_slot_timeout; irlap_apply_default_connection_parameters()
943 self->final_timeout = FINAL_TIMEOUT; irlap_apply_default_connection_parameters()
944 self->poll_timeout = POLL_TIMEOUT; irlap_apply_default_connection_parameters()
945 self->wd_timeout = WD_TIMEOUT; irlap_apply_default_connection_parameters()
948 self->qos_tx.baud_rate.value = 9600; irlap_apply_default_connection_parameters()
949 self->qos_rx.baud_rate.value = 9600; irlap_apply_default_connection_parameters()
950 self->qos_tx.max_turn_time.value = 0; irlap_apply_default_connection_parameters()
951 self->qos_rx.max_turn_time.value = 0; irlap_apply_default_connection_parameters()
952 self->qos_tx.min_turn_time.value = 0; irlap_apply_default_connection_parameters()
953 self->qos_rx.min_turn_time.value = 0; irlap_apply_default_connection_parameters()
954 self->qos_tx.data_size.value = 64; irlap_apply_default_connection_parameters()
955 self->qos_rx.data_size.value = 64; irlap_apply_default_connection_parameters()
956 self->qos_tx.window_size.value = 1; irlap_apply_default_connection_parameters()
957 self->qos_rx.window_size.value = 1; irlap_apply_default_connection_parameters()
958 self->qos_tx.additional_bofs.value = 12; irlap_apply_default_connection_parameters()
959 self->qos_rx.additional_bofs.value = 12; irlap_apply_default_connection_parameters()
960 self->qos_tx.link_disc_time.value = 0; irlap_apply_default_connection_parameters()
961 self->qos_rx.link_disc_time.value = 0; irlap_apply_default_connection_parameters()
963 irlap_flush_all_queues(self); irlap_apply_default_connection_parameters()
965 self->disconnect_pending = FALSE; irlap_apply_default_connection_parameters()
966 self->connect_pending = FALSE; irlap_apply_default_connection_parameters()
978 void irlap_apply_connection_parameters(struct irlap_cb *self, int now) irlap_apply_connection_parameters() argument
980 IRDA_ASSERT(self != NULL, return;); irlap_apply_connection_parameters()
981 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_apply_connection_parameters()
984 self->next_bofs = self->qos_tx.additional_bofs.value; irlap_apply_connection_parameters()
986 self->bofs_count = self->next_bofs; irlap_apply_connection_parameters()
989 irlap_change_speed(self, self->qos_tx.baud_rate.value, now); irlap_apply_connection_parameters()
991 self->window_size = self->qos_tx.window_size.value; irlap_apply_connection_parameters()
992 self->window = self->qos_tx.window_size.value; irlap_apply_connection_parameters()
999 self->line_capacity = irlap_apply_connection_parameters()
1000 irlap_max_line_capacity(self->qos_tx.baud_rate.value, irlap_apply_connection_parameters()
1001 self->qos_tx.max_turn_time.value); irlap_apply_connection_parameters()
1002 self->bytes_left = self->line_capacity; irlap_apply_connection_parameters()
1010 IRDA_ASSERT(self->qos_tx.max_turn_time.value != 0, return;); irlap_apply_connection_parameters()
1011 IRDA_ASSERT(self->qos_rx.max_turn_time.value != 0, return;); irlap_apply_connection_parameters()
1018 self->poll_timeout = msecs_to_jiffies( irlap_apply_connection_parameters()
1019 self->qos_tx.max_turn_time.value); irlap_apply_connection_parameters()
1025 self->final_timeout = msecs_to_jiffies( irlap_apply_connection_parameters()
1026 self->qos_rx.max_turn_time.value); irlap_apply_connection_parameters()
1032 self->wd_timeout = self->final_timeout * 2; irlap_apply_connection_parameters()
1049 if (self->qos_tx.link_disc_time.value == sysctl_warn_noreply_time) irlap_apply_connection_parameters()
1055 self->N1 = -2; /* Disable - Need to be multiple of 2*/ irlap_apply_connection_parameters()
1057 self->N1 = sysctl_warn_noreply_time * 1000 / irlap_apply_connection_parameters()
1058 self->qos_rx.max_turn_time.value; irlap_apply_connection_parameters()
1060 pr_debug("Setting N1 = %d\n", self->N1); irlap_apply_connection_parameters()
1063 self->N2 = self->qos_tx.link_disc_time.value * 1000 / irlap_apply_connection_parameters()
1064 self->qos_rx.max_turn_time.value; irlap_apply_connection_parameters()
1065 pr_debug("Setting N2 = %d\n", self->N2); irlap_apply_connection_parameters()
1076 struct irlap_cb *self; irlap_seq_start() local
1082 for (self = (struct irlap_cb *) hashbin_get_first(irlap); irlap_seq_start()
1083 self; self = (struct irlap_cb *) hashbin_get_next(irlap)) { irlap_seq_start()
1089 return self; irlap_seq_start()
1109 const struct irlap_cb *self = v; irlap_seq_show() local
1111 IRDA_ASSERT(self->magic == LAP_MAGIC, return -EINVAL;); irlap_seq_show()
1115 irlap_state[self->state]); irlap_seq_show()
1118 (self->netdev) ? self->netdev->name : "bug"); irlap_seq_show()
1119 seq_printf(seq, "hardware name: %s\n", self->hw_name); irlap_seq_show()
1121 seq_printf(seq, " caddr: %#02x, ", self->caddr); irlap_seq_show()
1122 seq_printf(seq, "saddr: %#08x, ", self->saddr); irlap_seq_show()
1123 seq_printf(seq, "daddr: %#08x\n", self->daddr); irlap_seq_show()
1126 self->window_size); irlap_seq_show()
1127 seq_printf(seq, "win: %d, ", self->window); irlap_seq_show()
1130 self->line_capacity); irlap_seq_show()
1131 seq_printf(seq, "bytes left: %d\n", self->bytes_left); irlap_seq_show()
1134 skb_queue_len(&self->txq)); irlap_seq_show()
1136 skb_queue_len(&self->wx_list)); irlap_seq_show()
1137 seq_printf(seq, "rbusy: %s", self->remote_busy ? irlap_seq_show()
1139 seq_printf(seq, " mbusy: %s\n", self->media_busy ? irlap_seq_show()
1142 seq_printf(seq, " retrans: %d ", self->retry_count); irlap_seq_show()
1143 seq_printf(seq, "vs: %d ", self->vs); irlap_seq_show()
1144 seq_printf(seq, "vr: %d ", self->vr); irlap_seq_show()
1145 seq_printf(seq, "va: %d\n", self->va); irlap_seq_show()
1150 self->qos_tx.baud_rate.value); irlap_seq_show()
1152 self->qos_tx.max_turn_time.value); irlap_seq_show()
1154 self->qos_tx.data_size.value); irlap_seq_show()
1156 self->qos_tx.window_size.value); irlap_seq_show()
1158 self->qos_tx.additional_bofs.value); irlap_seq_show()
1160 self->qos_tx.min_turn_time.value); irlap_seq_show()
1162 self->qos_tx.link_disc_time.value); irlap_seq_show()
1166 self->qos_rx.baud_rate.value); irlap_seq_show()
1168 self->qos_rx.max_turn_time.value); irlap_seq_show()
1170 self->qos_rx.data_size.value); irlap_seq_show()
1172 self->qos_rx.window_size.value); irlap_seq_show()
1174 self->qos_rx.additional_bofs.value); irlap_seq_show()
1176 self->qos_rx.min_turn_time.value); irlap_seq_show()
1178 self->qos_rx.link_disc_time.value); irlap_seq_show()
|
| H A D | irlap_frame.c | 47 static void irlap_send_i_frame(struct irlap_cb *self, struct sk_buff *skb,
51 * Function irlap_insert_info (self, skb)
57 static inline void irlap_insert_info(struct irlap_cb *self, irlap_insert_info() argument
67 cb->mtt = self->mtt_required; irlap_insert_info()
68 cb->next_speed = self->speed; irlap_insert_info()
71 self->mtt_required = 0; irlap_insert_info()
77 cb->xbofs = self->bofs_count; irlap_insert_info()
78 cb->next_xbofs = self->next_bofs; irlap_insert_info()
79 cb->xbofs_delay = self->xbofs_delay; irlap_insert_info()
82 self->xbofs_delay = 0; irlap_insert_info()
84 self->bofs_count = self->next_bofs; irlap_insert_info()
88 * Function irlap_queue_xmit (self, skb)
93 void irlap_queue_xmit(struct irlap_cb *self, struct sk_buff *skb) irlap_queue_xmit() argument
96 skb->dev = self->netdev; irlap_queue_xmit()
103 irlap_insert_info(self, skb); irlap_queue_xmit()
105 if (unlikely(self->mode & IRDA_MODE_MONITOR)) { irlap_queue_xmit()
107 self->netdev->name); irlap_queue_xmit()
120 void irlap_send_snrm_frame(struct irlap_cb *self, struct qos_info *qos) irlap_send_snrm_frame() argument
126 IRDA_ASSERT(self != NULL, return;); irlap_send_snrm_frame()
127 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_snrm_frame()
142 frame->caddr = CMD_FRAME | self->caddr; irlap_send_snrm_frame()
152 frame->saddr = cpu_to_le32(self->saddr); irlap_send_snrm_frame()
153 frame->daddr = cpu_to_le32(self->daddr); irlap_send_snrm_frame()
155 frame->ncaddr = self->caddr; irlap_send_snrm_frame()
157 ret = irlap_insert_qos_negotiation_params(self, tx_skb); irlap_send_snrm_frame()
163 irlap_queue_xmit(self, tx_skb); irlap_send_snrm_frame()
172 static void irlap_recv_snrm_cmd(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_snrm_cmd() argument
195 if (info->saddr != self->saddr) { irlap_recv_snrm_cmd()
200 irlap_do_event(self, RECV_SNRM_CMD, skb, info); irlap_recv_snrm_cmd()
203 irlap_do_event(self, RECV_SNRM_CMD, skb, NULL); irlap_recv_snrm_cmd()
213 void irlap_send_ua_response_frame(struct irlap_cb *self, struct qos_info *qos) irlap_send_ua_response_frame() argument
221 IRDA_ASSERT(self != NULL, return;); irlap_send_ua_response_frame()
222 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_ua_response_frame()
234 frame->caddr = self->caddr; irlap_send_ua_response_frame()
237 frame->saddr = cpu_to_le32(self->saddr); irlap_send_ua_response_frame()
238 frame->daddr = cpu_to_le32(self->daddr); irlap_send_ua_response_frame()
242 ret = irlap_insert_qos_negotiation_params(self, tx_skb); irlap_send_ua_response_frame()
249 irlap_queue_xmit(self, tx_skb); irlap_send_ua_response_frame()
259 void irlap_send_dm_frame( struct irlap_cb *self) irlap_send_dm_frame() argument
264 IRDA_ASSERT(self != NULL, return;); irlap_send_dm_frame()
265 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_dm_frame()
273 if (self->state == LAP_NDM) irlap_send_dm_frame()
276 frame->caddr = self->caddr; irlap_send_dm_frame()
280 irlap_queue_xmit(self, tx_skb); irlap_send_dm_frame()
289 void irlap_send_disc_frame(struct irlap_cb *self) irlap_send_disc_frame() argument
294 IRDA_ASSERT(self != NULL, return;); irlap_send_disc_frame()
295 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_disc_frame()
303 frame->caddr = self->caddr | CMD_FRAME; irlap_send_disc_frame()
306 irlap_queue_xmit(self, tx_skb); irlap_send_disc_frame()
315 void irlap_send_discovery_xid_frame(struct irlap_cb *self, int S, __u8 s, irlap_send_discovery_xid_frame() argument
326 IRDA_ASSERT(self != NULL, return;); irlap_send_discovery_xid_frame()
327 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_discovery_xid_frame()
347 frame->saddr = cpu_to_le32(self->saddr); irlap_send_discovery_xid_frame()
398 irlap_queue_xmit(self, tx_skb); irlap_send_discovery_xid_frame()
407 static void irlap_recv_discovery_xid_rsp(struct irlap_cb *self, irlap_recv_discovery_xid_rsp() argument
416 IRDA_ASSERT(self != NULL, return;); irlap_recv_discovery_xid_rsp()
417 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_recv_discovery_xid_rsp()
430 if ((info->saddr != self->saddr) && (info->saddr != BROADCAST)) { irlap_recv_discovery_xid_rsp()
442 discovery->data.saddr = self->saddr; irlap_recv_discovery_xid_rsp()
472 irlap_do_event(self, RECV_DISCOVERY_XID_RSP, skb, info); irlap_recv_discovery_xid_rsp()
481 static void irlap_recv_discovery_xid_cmd(struct irlap_cb *self, irlap_recv_discovery_xid_cmd() argument
501 if ((info->saddr != self->saddr) && (info->saddr != BROADCAST)) { irlap_recv_discovery_xid_cmd()
548 discovery->data.saddr = self->saddr; irlap_recv_discovery_xid_cmd()
573 irlap_do_event(self, RECV_DISCOVERY_XID_CMD, skb, info); irlap_recv_discovery_xid_cmd()
577 * Function irlap_send_rr_frame (self, command)
582 void irlap_send_rr_frame(struct irlap_cb *self, int command) irlap_send_rr_frame() argument
593 frame->caddr = self->caddr; irlap_send_rr_frame()
596 frame->control = RR | PF_BIT | (self->vr << 5); irlap_send_rr_frame()
598 irlap_queue_xmit(self, tx_skb); irlap_send_rr_frame()
602 * Function irlap_send_rd_frame (self)
607 void irlap_send_rd_frame(struct irlap_cb *self) irlap_send_rd_frame() argument
618 frame->caddr = self->caddr; irlap_send_rd_frame()
621 irlap_queue_xmit(self, tx_skb); irlap_send_rd_frame()
631 static inline void irlap_recv_rr_frame(struct irlap_cb *self, irlap_recv_rr_frame() argument
639 irlap_do_event(self, RECV_RR_CMD, skb, info); irlap_recv_rr_frame()
641 irlap_do_event(self, RECV_RR_RSP, skb, info); irlap_recv_rr_frame()
645 * Function irlap_recv_rnr_frame (self, skb, info)
650 static void irlap_recv_rnr_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_rnr_frame() argument
658 irlap_do_event(self, RECV_RNR_CMD, skb, info); irlap_recv_rnr_frame()
660 irlap_do_event(self, RECV_RNR_RSP, skb, info); irlap_recv_rnr_frame()
663 static void irlap_recv_rej_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_rej_frame() argument
670 irlap_do_event(self, RECV_REJ_CMD, skb, info); irlap_recv_rej_frame()
672 irlap_do_event(self, RECV_REJ_RSP, skb, info); irlap_recv_rej_frame()
675 static void irlap_recv_srej_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_srej_frame() argument
682 irlap_do_event(self, RECV_SREJ_CMD, skb, info); irlap_recv_srej_frame()
684 irlap_do_event(self, RECV_SREJ_RSP, skb, info); irlap_recv_srej_frame()
687 static void irlap_recv_disc_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_disc_frame() argument
692 irlap_do_event(self, RECV_DISC_CMD, skb, info); irlap_recv_disc_frame()
694 irlap_do_event(self, RECV_RD_RSP, skb, info); irlap_recv_disc_frame()
703 static inline void irlap_recv_ua_frame(struct irlap_cb *self, irlap_recv_ua_frame() argument
707 irlap_do_event(self, RECV_UA_RSP, skb, info); irlap_recv_ua_frame()
711 * Function irlap_send_data_primary(self, skb)
716 void irlap_send_data_primary(struct irlap_cb *self, struct sk_buff *skb) irlap_send_data_primary() argument
726 skb->data[1] = I_FRAME | (self->vs << 1); irlap_send_data_primary()
733 skb_queue_tail(&self->wx_list, skb); irlap_send_data_primary()
741 self->vs = (self->vs + 1) % 8; irlap_send_data_primary()
742 self->ack_required = FALSE; irlap_send_data_primary()
743 self->window -= 1; irlap_send_data_primary()
745 irlap_send_i_frame( self, tx_skb, CMD_FRAME); irlap_send_data_primary()
748 irlap_send_ui_frame(self, skb_get(skb), self->caddr, CMD_FRAME); irlap_send_data_primary()
749 self->window -= 1; irlap_send_data_primary()
753 * Function irlap_send_data_primary_poll (self, skb)
757 void irlap_send_data_primary_poll(struct irlap_cb *self, struct sk_buff *skb) irlap_send_data_primary_poll() argument
763 del_timer(&self->poll_timer); irlap_send_data_primary_poll()
772 skb->data[1] = I_FRAME | (self->vs << 1); irlap_send_data_primary_poll()
779 skb_queue_tail(&self->wx_list, skb); irlap_send_data_primary_poll()
794 self->vs = (self->vs + 1) % 8; irlap_send_data_primary_poll()
795 self->ack_required = FALSE; irlap_send_data_primary_poll()
797 irlap_next_state(self, LAP_NRM_P); irlap_send_data_primary_poll()
798 irlap_send_i_frame(self, tx_skb, CMD_FRAME); irlap_send_data_primary_poll()
802 if (self->ack_required) { irlap_send_data_primary_poll()
803 irlap_send_ui_frame(self, skb_get(skb), self->caddr, CMD_FRAME); irlap_send_data_primary_poll()
804 irlap_next_state(self, LAP_NRM_P); irlap_send_data_primary_poll()
805 irlap_send_rr_frame(self, CMD_FRAME); irlap_send_data_primary_poll()
806 self->ack_required = FALSE; irlap_send_data_primary_poll()
809 irlap_next_state(self, LAP_NRM_P); irlap_send_data_primary_poll()
810 irlap_send_ui_frame(self, skb_get(skb), self->caddr, CMD_FRAME); irlap_send_data_primary_poll()
816 transmission_time = self->final_timeout; irlap_send_data_primary_poll()
819 self->window = self->window_size; irlap_send_data_primary_poll()
825 transmission_time -= (self->final_timeout * self->bytes_left irlap_send_data_primary_poll()
826 / self->line_capacity); irlap_send_data_primary_poll()
828 __func__, self->final_timeout, self->bytes_left, irlap_send_data_primary_poll()
829 self->line_capacity, transmission_time); irlap_send_data_primary_poll()
832 self->bytes_left = self->line_capacity; irlap_send_data_primary_poll()
849 irlap_start_final_timer(self, self->final_timeout + transmission_time); irlap_send_data_primary_poll()
862 * Function irlap_send_data_secondary_final (self, skb)
867 void irlap_send_data_secondary_final(struct irlap_cb *self, irlap_send_data_secondary_final() argument
872 IRDA_ASSERT(self != NULL, return;); irlap_send_data_secondary_final()
873 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_data_secondary_final()
883 skb->data[1] = I_FRAME | (self->vs << 1); irlap_send_data_secondary_final()
890 skb_queue_tail(&self->wx_list, skb); irlap_send_data_secondary_final()
899 self->vs = (self->vs + 1) % 8; irlap_send_data_secondary_final()
900 self->ack_required = FALSE; irlap_send_data_secondary_final()
902 irlap_send_i_frame(self, tx_skb, RSP_FRAME); irlap_send_data_secondary_final()
904 if (self->ack_required) { irlap_send_data_secondary_final()
905 irlap_send_ui_frame(self, skb_get(skb), self->caddr, RSP_FRAME); irlap_send_data_secondary_final()
906 irlap_send_rr_frame(self, RSP_FRAME); irlap_send_data_secondary_final()
907 self->ack_required = FALSE; irlap_send_data_secondary_final()
910 irlap_send_ui_frame(self, skb_get(skb), self->caddr, RSP_FRAME); irlap_send_data_secondary_final()
914 self->window = self->window_size; irlap_send_data_secondary_final()
917 self->bytes_left = self->line_capacity; irlap_send_data_secondary_final()
920 irlap_start_wd_timer(self, self->wd_timeout); irlap_send_data_secondary_final()
924 * Function irlap_send_data_secondary (self, skb)
929 void irlap_send_data_secondary(struct irlap_cb *self, struct sk_buff *skb) irlap_send_data_secondary() argument
940 skb->data[1] = I_FRAME | (self->vs << 1); irlap_send_data_secondary()
947 skb_queue_tail(&self->wx_list, skb); irlap_send_data_secondary()
954 self->vs = (self->vs + 1) % 8; irlap_send_data_secondary()
955 self->ack_required = FALSE; irlap_send_data_secondary()
956 self->window -= 1; irlap_send_data_secondary()
958 irlap_send_i_frame(self, tx_skb, RSP_FRAME); irlap_send_data_secondary()
960 irlap_send_ui_frame(self, skb_get(skb), self->caddr, RSP_FRAME); irlap_send_data_secondary()
961 self->window -= 1; irlap_send_data_secondary()
972 void irlap_resend_rejected_frames(struct irlap_cb *self, int command) irlap_resend_rejected_frames() argument
977 IRDA_ASSERT(self != NULL, return;); irlap_resend_rejected_frames()
978 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_resend_rejected_frames()
981 skb_queue_walk(&self->wx_list, skb) { irlap_resend_rejected_frames()
982 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_resend_rejected_frames()
1000 if (skb_queue_is_last(&self->wx_list, skb)) irlap_resend_rejected_frames()
1005 irlap_send_i_frame(self, tx_skb, command); irlap_resend_rejected_frames()
1011 while (!skb_queue_empty(&self->txq)) { irlap_resend_rejected_frames()
1014 if (self->window > 0) { irlap_resend_rejected_frames()
1015 skb = skb_dequeue( &self->txq); irlap_resend_rejected_frames()
1022 if ((self->window > 1) && irlap_resend_rejected_frames()
1023 !skb_queue_empty(&self->txq)) { irlap_resend_rejected_frames()
1024 irlap_send_data_primary(self, skb); irlap_resend_rejected_frames()
1026 irlap_send_data_primary_poll(self, skb); irlap_resend_rejected_frames()
1034 void irlap_resend_rejected_frame(struct irlap_cb *self, int command) irlap_resend_rejected_frame() argument
1039 IRDA_ASSERT(self != NULL, return;); irlap_resend_rejected_frame()
1040 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_resend_rejected_frame()
1043 skb = skb_peek(&self->wx_list); irlap_resend_rejected_frame()
1045 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_resend_rejected_frame()
1063 irlap_send_i_frame(self, tx_skb, command); irlap_resend_rejected_frame()
1068 * Function irlap_send_ui_frame (self, skb, command)
1073 void irlap_send_ui_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_send_ui_frame() argument
1076 IRDA_ASSERT(self != NULL, return;); irlap_send_ui_frame()
1077 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_send_ui_frame()
1083 irlap_queue_xmit(self, skb); irlap_send_ui_frame()
1091 static void irlap_send_i_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_send_i_frame() argument
1095 skb->data[0] = self->caddr; irlap_send_i_frame()
1099 skb->data[1] |= (self->vr << 5); /* insert nr */ irlap_send_i_frame()
1101 irlap_queue_xmit(self, skb); irlap_send_i_frame()
1110 static inline void irlap_recv_i_frame(struct irlap_cb *self, irlap_recv_i_frame() argument
1120 irlap_do_event(self, RECV_I_CMD, skb, info); irlap_recv_i_frame()
1122 irlap_do_event(self, RECV_I_RSP, skb, info); irlap_recv_i_frame()
1126 * Function irlap_recv_ui_frame (self, skb, info)
1131 static void irlap_recv_ui_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_ui_frame() argument
1136 irlap_do_event(self, RECV_UI_FRAME, skb, info); irlap_recv_ui_frame()
1145 static void irlap_recv_frmr_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_frmr_frame() argument
1151 IRDA_ASSERT(self != NULL, return;); irlap_recv_frmr_frame()
1152 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_recv_frmr_frame()
1184 irlap_do_event(self, RECV_FRMR_RSP, skb, info); irlap_recv_frmr_frame()
1188 * Function irlap_send_test_frame (self, daddr)
1193 void irlap_send_test_frame(struct irlap_cb *self, __u8 caddr, __u32 daddr, irlap_send_test_frame() argument
1210 frame->saddr = cpu_to_le32(self->saddr); irlap_send_test_frame()
1223 irlap_wait_min_turn_around(self, &self->qos_tx); irlap_send_test_frame()
1224 irlap_queue_xmit(self, tx_skb); irlap_send_test_frame()
1228 * Function irlap_recv_test_frame (self, skb)
1233 static void irlap_recv_test_frame(struct irlap_cb *self, struct sk_buff *skb, irlap_recv_test_frame() argument
1257 if ((info->saddr != self->saddr) && irlap_recv_test_frame()
1264 irlap_do_event(self, RECV_TEST_CMD, skb, info); irlap_recv_test_frame()
1266 irlap_do_event(self, RECV_TEST_RSP, skb, info); irlap_recv_test_frame()
1289 struct irlap_cb *self; irlap_driver_rcv() local
1298 self = (struct irlap_cb *) dev->atalk_ptr; irlap_driver_rcv()
1301 if (!self || self->magic != LAP_MAGIC) irlap_driver_rcv()
1327 if ((info.caddr != self->caddr) && (info.caddr != CBROADCAST)) { irlap_driver_rcv()
1337 irlap_recv_i_frame(self, skb, &info, command); irlap_driver_rcv()
1351 irlap_recv_rr_frame(self, skb, &info, command); irlap_driver_rcv()
1354 irlap_recv_rnr_frame(self, skb, &info, command); irlap_driver_rcv()
1357 irlap_recv_rej_frame(self, skb, &info, command); irlap_driver_rcv()
1360 irlap_recv_srej_frame(self, skb, &info, command); irlap_driver_rcv()
1374 irlap_recv_discovery_xid_rsp(self, skb, &info); irlap_driver_rcv()
1377 irlap_recv_discovery_xid_cmd(self, skb, &info); irlap_driver_rcv()
1380 irlap_recv_snrm_cmd(self, skb, &info); irlap_driver_rcv()
1383 irlap_do_event(self, RECV_DM_RSP, skb, &info); irlap_driver_rcv()
1386 irlap_recv_disc_frame(self, skb, &info, command); irlap_driver_rcv()
1389 irlap_recv_test_frame(self, skb, &info, command); irlap_driver_rcv()
1392 irlap_recv_ua_frame(self, skb, &info); irlap_driver_rcv()
1395 irlap_recv_frmr_frame(self, skb, &info); irlap_driver_rcv()
1398 irlap_recv_ui_frame(self, skb, &info); irlap_driver_rcv()
|
| H A D | irttp.c | 45 static void __irttp_close_tsap(struct tsap_cb *self);
59 static void irttp_run_tx_queue(struct tsap_cb *self);
60 static void irttp_run_rx_queue(struct tsap_cb *self);
62 static void irttp_flush_queues(struct tsap_cb *self);
63 static void irttp_fragment_skb(struct tsap_cb *self, struct sk_buff *skb);
64 static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self);
137 * Function irttp_start_todo_timer (self, timeout)
143 static inline void irttp_start_todo_timer(struct tsap_cb *self, int timeout) irttp_start_todo_timer() argument
146 mod_timer(&self->todo_timer, jiffies + timeout); irttp_start_todo_timer()
165 struct tsap_cb *self = (struct tsap_cb *) data; irttp_todo_expired() local
168 if (!self || self->magic != TTP_TSAP_MAGIC) irttp_todo_expired()
171 pr_debug("%s(instance=%p)\n", __func__, self); irttp_todo_expired()
174 irttp_run_rx_queue(self); irttp_todo_expired()
175 irttp_run_tx_queue(self); irttp_todo_expired()
178 if (test_bit(0, &self->disconnect_pend)) { irttp_todo_expired()
180 if (skb_queue_empty(&self->tx_queue)) { irttp_todo_expired()
182 clear_bit(0, &self->disconnect_pend); /* FALSE */ irttp_todo_expired()
184 /* Note : self->disconnect_skb may be NULL */ irttp_todo_expired()
185 irttp_disconnect_request(self, self->disconnect_skb, irttp_todo_expired()
187 self->disconnect_skb = NULL; irttp_todo_expired()
190 irttp_start_todo_timer(self, HZ/10); irttp_todo_expired()
198 if (self->close_pend) irttp_todo_expired()
200 irttp_close_tsap(self); irttp_todo_expired()
204 * Function irttp_flush_queues (self)
208 static void irttp_flush_queues(struct tsap_cb *self) irttp_flush_queues() argument
212 IRDA_ASSERT(self != NULL, return;); irttp_flush_queues()
213 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_flush_queues()
216 while ((skb = skb_dequeue(&self->tx_queue)) != NULL) irttp_flush_queues()
220 while ((skb = skb_dequeue(&self->rx_queue)) != NULL) irttp_flush_queues()
224 while ((skb = skb_dequeue(&self->rx_fragments)) != NULL) irttp_flush_queues()
229 * Function irttp_reassemble (self)
235 static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self) irttp_reassemble_skb() argument
240 IRDA_ASSERT(self != NULL, return NULL;); irttp_reassemble_skb()
241 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return NULL;); irttp_reassemble_skb()
243 pr_debug("%s(), self->rx_sdu_size=%d\n", __func__, irttp_reassemble_skb()
244 self->rx_sdu_size); irttp_reassemble_skb()
246 skb = dev_alloc_skb(TTP_HEADER + self->rx_sdu_size); irttp_reassemble_skb()
255 skb_put(skb, self->rx_sdu_size); irttp_reassemble_skb()
260 while ((frag = skb_dequeue(&self->rx_fragments)) != NULL) { irttp_reassemble_skb()
268 __func__, n, self->rx_sdu_size, self->rx_max_sdu_size); irttp_reassemble_skb()
269 /* Note : irttp_run_rx_queue() calculate self->rx_sdu_size irttp_reassemble_skb()
271 * have n == self->rx_sdu_size, except in cases where we irttp_reassemble_skb()
272 * droped the last fragment (when self->rx_sdu_size exceed irttp_reassemble_skb()
273 * self->rx_max_sdu_size), where n < self->rx_sdu_size. irttp_reassemble_skb()
275 IRDA_ASSERT(n <= self->rx_sdu_size, n = self->rx_sdu_size;); irttp_reassemble_skb()
280 self->rx_sdu_size = 0; irttp_reassemble_skb()
291 static inline void irttp_fragment_skb(struct tsap_cb *self, irttp_fragment_skb() argument
297 IRDA_ASSERT(self != NULL, return;); irttp_fragment_skb()
298 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_fragment_skb()
304 while (skb->len > self->max_seg_size) { irttp_fragment_skb()
308 frag = alloc_skb(self->max_seg_size+self->max_header_size, irttp_fragment_skb()
313 skb_reserve(frag, self->max_header_size); irttp_fragment_skb()
316 skb_copy_from_linear_data(skb, skb_put(frag, self->max_seg_size), irttp_fragment_skb()
317 self->max_seg_size); irttp_fragment_skb()
324 skb_pull(skb, self->max_seg_size); irttp_fragment_skb()
327 skb_queue_tail(&self->tx_queue, frag); irttp_fragment_skb()
336 skb_queue_tail(&self->tx_queue, skb); irttp_fragment_skb()
340 * Function irttp_param_max_sdu_size (self, param)
349 struct tsap_cb *self; irttp_param_max_sdu_size() local
351 self = instance; irttp_param_max_sdu_size()
353 IRDA_ASSERT(self != NULL, return -1;); irttp_param_max_sdu_size()
354 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_param_max_sdu_size()
357 param->pv.i = self->tx_max_sdu_size; irttp_param_max_sdu_size()
359 self->tx_max_sdu_size = param->pv.i; irttp_param_max_sdu_size()
391 struct tsap_cb *self; irttp_open_tsap() local
406 self = kzalloc(sizeof(struct tsap_cb), GFP_ATOMIC); irttp_open_tsap()
407 if (self == NULL) irttp_open_tsap()
411 irttp_init_tsap(self); irttp_open_tsap()
414 self->todo_timer.data = (unsigned long) self; irttp_open_tsap()
415 self->todo_timer.function = &irttp_todo_expired; irttp_open_tsap()
427 ttp_notify.instance = self; irttp_open_tsap()
430 self->magic = TTP_TSAP_MAGIC; irttp_open_tsap()
431 self->connected = FALSE; irttp_open_tsap()
439 __irttp_close_tsap(self); irttp_open_tsap()
448 self->stsap_sel = lsap->slsap_sel; irttp_open_tsap()
449 pr_debug("%s(), stsap_sel=%02x\n", __func__, self->stsap_sel); irttp_open_tsap()
451 self->notify = *notify; irttp_open_tsap()
452 self->lsap = lsap; irttp_open_tsap()
454 hashbin_insert(irttp->tsaps, (irda_queue_t *) self, (long) self, NULL); irttp_open_tsap()
457 self->initial_credit = TTP_RX_MAX_CREDIT; irttp_open_tsap()
459 self->initial_credit = credit; irttp_open_tsap()
461 return self; irttp_open_tsap()
472 static void __irttp_close_tsap(struct tsap_cb *self) __irttp_close_tsap() argument
475 IRDA_ASSERT(self != NULL, return;); __irttp_close_tsap()
476 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); __irttp_close_tsap()
478 irttp_flush_queues(self); __irttp_close_tsap()
480 del_timer(&self->todo_timer); __irttp_close_tsap()
484 if (self->disconnect_skb) __irttp_close_tsap()
485 dev_kfree_skb(self->disconnect_skb); __irttp_close_tsap()
487 self->connected = FALSE; __irttp_close_tsap()
488 self->magic = ~TTP_TSAP_MAGIC; __irttp_close_tsap()
490 kfree(self); __irttp_close_tsap()
494 * Function irttp_close (self)
503 int irttp_close_tsap(struct tsap_cb *self) irttp_close_tsap() argument
507 IRDA_ASSERT(self != NULL, return -1;); irttp_close_tsap()
508 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_close_tsap()
511 if (self->connected) { irttp_close_tsap()
513 if (!test_bit(0, &self->disconnect_pend)) { irttp_close_tsap()
516 irttp_disconnect_request(self, NULL, P_NORMAL); irttp_close_tsap()
518 self->close_pend = TRUE; irttp_close_tsap()
519 irttp_start_todo_timer(self, HZ/10); irttp_close_tsap()
524 tsap = hashbin_remove(irttp->tsaps, (long) self, NULL); irttp_close_tsap()
526 IRDA_ASSERT(tsap == self, return -1;); irttp_close_tsap()
529 if (self->lsap) { irttp_close_tsap()
530 irlmp_close_lsap(self->lsap); irttp_close_tsap()
531 self->lsap = NULL; irttp_close_tsap()
534 __irttp_close_tsap(self); irttp_close_tsap()
541 * Function irttp_udata_request (self, skb)
546 int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb) irttp_udata_request() argument
550 IRDA_ASSERT(self != NULL, return -1;); irttp_udata_request()
551 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_udata_request()
561 if (!self->connected) { irttp_udata_request()
567 if (skb->len > self->max_seg_size) { irttp_udata_request()
574 irlmp_udata_request(self->lsap, skb); irttp_udata_request()
575 self->stats.tx_packets++; irttp_udata_request()
592 int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb) irttp_data_request() argument
597 IRDA_ASSERT(self != NULL, return -1;); irttp_data_request()
598 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_data_request()
602 skb_queue_len(&self->tx_queue)); irttp_data_request()
611 if (!self->connected) { irttp_data_request()
621 if ((self->tx_max_sdu_size == 0) && (skb->len > self->max_seg_size)) { irttp_data_request()
632 if ((self->tx_max_sdu_size != 0) && irttp_data_request()
633 (self->tx_max_sdu_size != TTP_SAR_UNBOUND) && irttp_data_request()
634 (skb->len > self->tx_max_sdu_size)) { irttp_data_request()
643 if (skb_queue_len(&self->tx_queue) >= TTP_TX_MAX_QUEUE) { irttp_data_request()
647 irttp_run_tx_queue(self); irttp_data_request()
656 if ((self->tx_max_sdu_size == 0) || (skb->len < self->max_seg_size)) { irttp_data_request()
662 skb_queue_tail(&self->tx_queue, skb); irttp_data_request()
670 irttp_fragment_skb(self, skb); irttp_data_request()
674 if ((!self->tx_sdu_busy) && irttp_data_request()
675 (skb_queue_len(&self->tx_queue) > TTP_TX_HIGH_THRESHOLD)) { irttp_data_request()
677 if (self->notify.flow_indication) { irttp_data_request()
678 self->notify.flow_indication(self->notify.instance, irttp_data_request()
679 self, FLOW_STOP); irttp_data_request()
681 /* self->tx_sdu_busy is the state of the client. irttp_data_request()
688 self->tx_sdu_busy = TRUE; irttp_data_request()
692 irttp_run_tx_queue(self); irttp_data_request()
703 * Function irttp_run_tx_queue (self)
708 static void irttp_run_tx_queue(struct tsap_cb *self) irttp_run_tx_queue() argument
716 self->send_credit, skb_queue_len(&self->tx_queue)); irttp_run_tx_queue()
719 if (irda_lock(&self->tx_queue_lock) == FALSE) irttp_run_tx_queue()
725 while ((self->send_credit > 0) && irttp_run_tx_queue()
726 (!irlmp_lap_tx_queue_full(self->lsap)) && irttp_run_tx_queue()
727 (skb = skb_dequeue(&self->tx_queue))) { irttp_run_tx_queue()
733 spin_lock_irqsave(&self->lock, flags); irttp_run_tx_queue()
735 n = self->avail_credit; irttp_run_tx_queue()
736 self->avail_credit = 0; irttp_run_tx_queue()
740 self->avail_credit = n-127; irttp_run_tx_queue()
743 self->remote_credit += n; irttp_run_tx_queue()
744 self->send_credit--; irttp_run_tx_queue()
746 spin_unlock_irqrestore(&self->lock, flags); irttp_run_tx_queue()
757 * stored in in IrLAP (self->wx_list). When we are within irttp_run_tx_queue()
779 irlmp_data_request(self->lsap, skb); irttp_run_tx_queue()
780 self->stats.tx_packets++; irttp_run_tx_queue()
789 if ((self->tx_sdu_busy) && irttp_run_tx_queue()
790 (skb_queue_len(&self->tx_queue) < TTP_TX_LOW_THRESHOLD) && irttp_run_tx_queue()
791 (!self->close_pend)) { irttp_run_tx_queue()
792 if (self->notify.flow_indication) irttp_run_tx_queue()
793 self->notify.flow_indication(self->notify.instance, irttp_run_tx_queue()
794 self, FLOW_START); irttp_run_tx_queue()
796 /* self->tx_sdu_busy is the state of the client. irttp_run_tx_queue()
799 self->tx_sdu_busy = FALSE; irttp_run_tx_queue()
803 self->tx_queue_lock = 0; irttp_run_tx_queue()
807 * Function irttp_give_credit (self)
812 static inline void irttp_give_credit(struct tsap_cb *self) irttp_give_credit() argument
818 IRDA_ASSERT(self != NULL, return;); irttp_give_credit()
819 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_give_credit()
823 self->send_credit, self->avail_credit, self->remote_credit); irttp_give_credit()
838 spin_lock_irqsave(&self->lock, flags); irttp_give_credit()
840 n = self->avail_credit; irttp_give_credit()
841 self->avail_credit = 0; irttp_give_credit()
845 self->avail_credit = n - 127; irttp_give_credit()
848 self->remote_credit += n; irttp_give_credit()
850 spin_unlock_irqrestore(&self->lock, flags); irttp_give_credit()
855 irlmp_data_request(self->lsap, tx_skb); irttp_give_credit()
856 self->stats.tx_packets++; irttp_give_credit()
868 struct tsap_cb *self; irttp_udata_indication() local
871 self = instance; irttp_udata_indication()
873 IRDA_ASSERT(self != NULL, return -1;); irttp_udata_indication()
874 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_udata_indication()
877 self->stats.rx_packets++; irttp_udata_indication()
880 if (self->notify.udata_indication) { irttp_udata_indication()
881 err = self->notify.udata_indication(self->notify.instance, irttp_udata_indication()
882 self, skb); irttp_udata_indication()
902 struct tsap_cb *self; irttp_data_indication() local
906 self = instance; irttp_data_indication()
910 self->stats.rx_packets++; irttp_data_indication()
917 spin_lock_irqsave(&self->lock, flags); irttp_data_indication()
918 self->send_credit += n; irttp_data_indication()
920 self->remote_credit--; irttp_data_indication()
921 spin_unlock_irqrestore(&self->lock, flags); irttp_data_indication()
932 skb_queue_tail(&self->rx_queue, skb); irttp_data_indication()
950 irttp_run_rx_queue(self); irttp_data_indication()
964 if (self->send_credit == n) { irttp_data_indication()
966 irttp_run_tx_queue(self); irttp_data_indication()
976 * Function irttp_status_indication (self, reason)
984 struct tsap_cb *self; irttp_status_indication() local
986 self = instance; irttp_status_indication()
988 IRDA_ASSERT(self != NULL, return;); irttp_status_indication()
989 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_status_indication()
992 if (self->close_pend) irttp_status_indication()
998 if (self->notify.status_indication != NULL) irttp_status_indication()
999 self->notify.status_indication(self->notify.instance, irttp_status_indication()
1006 * Function irttp_flow_indication (self, reason)
1013 struct tsap_cb *self; irttp_flow_indication() local
1015 self = instance; irttp_flow_indication()
1017 IRDA_ASSERT(self != NULL, return;); irttp_flow_indication()
1018 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_flow_indication()
1020 pr_debug("%s(instance=%p)\n", __func__, self); irttp_flow_indication()
1031 irttp_run_tx_queue(self); irttp_flow_indication()
1045 if (self->disconnect_pend) irttp_flow_indication()
1046 irttp_start_todo_timer(self, 0); irttp_flow_indication()
1050 * Function irttp_flow_request (self, command)
1056 void irttp_flow_request(struct tsap_cb *self, LOCAL_FLOW flow) irttp_flow_request() argument
1058 IRDA_ASSERT(self != NULL, return;); irttp_flow_request()
1059 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_flow_request()
1064 self->rx_sdu_busy = TRUE; irttp_flow_request()
1068 self->rx_sdu_busy = FALSE; irttp_flow_request()
1072 irttp_run_rx_queue(self); irttp_flow_request()
1082 * Function irttp_connect_request (self, dtsap_sel, daddr, qos)
1087 int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel, irttp_connect_request() argument
1098 IRDA_ASSERT(self != NULL, return -EBADR;); irttp_connect_request()
1099 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -EBADR;); irttp_connect_request()
1101 if (self->connected) { irttp_connect_request()
1127 self->connected = FALSE; irttp_connect_request()
1128 self->avail_credit = 0; irttp_connect_request()
1129 self->rx_max_sdu_size = max_sdu_size; irttp_connect_request()
1130 self->rx_sdu_size = 0; irttp_connect_request()
1131 self->rx_sdu_busy = FALSE; irttp_connect_request()
1132 self->dtsap_sel = dtsap_sel; irttp_connect_request()
1134 n = self->initial_credit; irttp_connect_request()
1136 self->remote_credit = 0; irttp_connect_request()
1137 self->send_credit = 0; irttp_connect_request()
1143 self->avail_credit = n - 127; irttp_connect_request()
1147 self->remote_credit = n; irttp_connect_request()
1173 return irlmp_connect_request(self->lsap, dtsap_sel, saddr, daddr, qos, irttp_connect_request()
1188 struct tsap_cb *self; irttp_connect_confirm() local
1194 self = instance; irttp_connect_confirm()
1196 IRDA_ASSERT(self != NULL, return;); irttp_connect_confirm()
1197 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_connect_confirm()
1200 self->max_seg_size = max_seg_size - TTP_HEADER; irttp_connect_confirm()
1201 self->max_header_size = max_header_size + TTP_HEADER; irttp_connect_confirm()
1218 self->send_credit = n; irttp_connect_confirm()
1219 self->tx_max_sdu_size = 0; irttp_connect_confirm()
1220 self->connected = TRUE; irttp_connect_confirm()
1230 ret = irda_param_extract_all(self, skb->data+1, irttp_connect_confirm()
1248 self->send_credit, self->avail_credit, self->remote_credit); irttp_connect_confirm()
1251 self->tx_max_sdu_size); irttp_connect_confirm()
1253 if (self->notify.connect_confirm) { irttp_connect_confirm()
1254 self->notify.connect_confirm(self->notify.instance, self, qos, irttp_connect_confirm()
1255 self->tx_max_sdu_size, irttp_connect_confirm()
1256 self->max_header_size, skb); irttp_connect_confirm()
1271 struct tsap_cb *self; irttp_connect_indication() local
1278 self = instance; irttp_connect_indication()
1280 IRDA_ASSERT(self != NULL, return;); irttp_connect_indication()
1281 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_connect_indication()
1286 self->max_seg_size = max_seg_size - TTP_HEADER; irttp_connect_indication()
1287 self->max_header_size = max_header_size+TTP_HEADER; irttp_connect_indication()
1289 pr_debug("%s(), TSAP sel=%02x\n", __func__, self->stsap_sel); irttp_connect_indication()
1292 self->dtsap_sel = lsap->dlsap_sel; irttp_connect_indication()
1296 self->send_credit = n; irttp_connect_indication()
1297 self->tx_max_sdu_size = 0; irttp_connect_indication()
1307 ret = irda_param_extract_all(self, skb->data+1, irttp_connect_indication()
1325 if (self->notify.connect_indication) { irttp_connect_indication()
1326 self->notify.connect_indication(self->notify.instance, self, irttp_connect_indication()
1327 qos, self->tx_max_sdu_size, irttp_connect_indication()
1328 self->max_header_size, skb); irttp_connect_indication()
1340 int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size, irttp_connect_response() argument
1348 IRDA_ASSERT(self != NULL, return -1;); irttp_connect_response()
1349 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_connect_response()
1352 self->stsap_sel); irttp_connect_response()
1373 self->avail_credit = 0; irttp_connect_response()
1374 self->remote_credit = 0; irttp_connect_response()
1375 self->rx_max_sdu_size = max_sdu_size; irttp_connect_response()
1376 self->rx_sdu_size = 0; irttp_connect_response()
1377 self->rx_sdu_busy = FALSE; irttp_connect_response()
1379 n = self->initial_credit; irttp_connect_response()
1383 self->avail_credit = n - 127; irttp_connect_response()
1387 self->remote_credit = n; irttp_connect_response()
1388 self->connected = TRUE; irttp_connect_response()
1401 /* irda_param_insert(self, IRTTP_MAX_SDU_SIZE, frame+1, */ irttp_connect_response()
1416 ret = irlmp_connect_response(self->lsap, tx_skb); irttp_connect_response()
1423 * Function irttp_dup (self, instance)
1477 * Function irttp_disconnect_request (self)
1483 int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata, irttp_disconnect_request() argument
1488 IRDA_ASSERT(self != NULL, return -1;); irttp_disconnect_request()
1489 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;); irttp_disconnect_request()
1492 if (!self->connected) { irttp_disconnect_request()
1504 if (test_and_set_bit(0, &self->disconnect_pend)) { irttp_disconnect_request()
1511 irttp_run_tx_queue(self); irttp_disconnect_request()
1518 if (!skb_queue_empty(&self->tx_queue)) { irttp_disconnect_request()
1526 irttp_flush_queues(self); irttp_disconnect_request()
1533 self->disconnect_skb = userdata; /* May be NULL */ irttp_disconnect_request()
1535 irttp_run_tx_queue(self); irttp_disconnect_request()
1537 irttp_start_todo_timer(self, HZ/10); irttp_disconnect_request()
1541 /* Note : we don't need to check if self->rx_queue is full and the irttp_disconnect_request()
1542 * state of self->rx_sdu_busy because the disconnect response will irttp_disconnect_request()
1547 self->connected = FALSE; irttp_disconnect_request()
1562 ret = irlmp_disconnect_request(self->lsap, userdata); irttp_disconnect_request()
1565 clear_bit(0, &self->disconnect_pend); /* FALSE */ irttp_disconnect_request()
1572 * Function irttp_disconnect_indication (self, reason)
1580 struct tsap_cb *self; irttp_disconnect_indication() local
1582 self = instance; irttp_disconnect_indication()
1584 IRDA_ASSERT(self != NULL, return;); irttp_disconnect_indication()
1585 IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;); irttp_disconnect_indication()
1588 self->connected = FALSE; irttp_disconnect_indication()
1591 if (self->close_pend) { irttp_disconnect_indication()
1596 irttp_close_tsap(self); irttp_disconnect_indication()
1603 * attempted to close the tsap and self->close_pend would be TRUE. irttp_disconnect_indication()
1607 if (self->notify.disconnect_indication) irttp_disconnect_indication()
1608 self->notify.disconnect_indication(self->notify.instance, self, irttp_disconnect_indication()
1616 * Function irttp_do_data_indication (self, skb)
1622 static void irttp_do_data_indication(struct tsap_cb *self, struct sk_buff *skb) irttp_do_data_indication() argument
1627 if (self->close_pend) { irttp_do_data_indication()
1632 err = self->notify.data_indication(self->notify.instance, self, skb); irttp_do_data_indication()
1643 self->rx_sdu_busy = TRUE; irttp_do_data_indication()
1650 skb_queue_head(&self->rx_queue, skb); irttp_do_data_indication()
1655 * Function irttp_run_rx_queue (self)
1660 static void irttp_run_rx_queue(struct tsap_cb *self) irttp_run_rx_queue() argument
1666 self->send_credit, self->avail_credit, self->remote_credit); irttp_run_rx_queue()
1669 if (irda_lock(&self->rx_queue_lock) == FALSE) irttp_run_rx_queue()
1675 while (!self->rx_sdu_busy && (skb = skb_dequeue(&self->rx_queue))) { irttp_run_rx_queue()
1683 self->rx_sdu_size += skb->len; irttp_run_rx_queue()
1691 if (self->rx_max_sdu_size == TTP_SAR_DISABLE) { irttp_run_rx_queue()
1692 irttp_do_data_indication(self, skb); irttp_run_rx_queue()
1693 self->rx_sdu_size = 0; irttp_run_rx_queue()
1704 if (self->rx_sdu_size <= self->rx_max_sdu_size) { irttp_run_rx_queue()
1707 skb_queue_tail(&self->rx_fragments, skb); irttp_run_rx_queue()
1717 if ((self->rx_sdu_size <= self->rx_max_sdu_size) || irttp_run_rx_queue()
1718 (self->rx_max_sdu_size == TTP_SAR_UNBOUND)) { irttp_run_rx_queue()
1725 if (!skb_queue_empty(&self->rx_fragments)) { irttp_run_rx_queue()
1726 skb_queue_tail(&self->rx_fragments, irttp_run_rx_queue()
1729 skb = irttp_reassemble_skb(self); irttp_run_rx_queue()
1733 irttp_do_data_indication(self, skb); irttp_run_rx_queue()
1741 skb = irttp_reassemble_skb(self); irttp_run_rx_queue()
1743 irttp_do_data_indication(self, skb); irttp_run_rx_queue()
1745 self->rx_sdu_size = 0; irttp_run_rx_queue()
1756 * No need to spinlock, write is atomic and self correcting... irttp_run_rx_queue()
1759 self->avail_credit = (self->initial_credit - irttp_run_rx_queue()
1760 (self->remote_credit + irttp_run_rx_queue()
1761 skb_queue_len(&self->rx_queue) + irttp_run_rx_queue()
1762 skb_queue_len(&self->rx_fragments))); irttp_run_rx_queue()
1765 if ((self->remote_credit <= TTP_RX_MIN_CREDIT) && irttp_run_rx_queue()
1766 (self->avail_credit > 0)) { irttp_run_rx_queue()
1768 irttp_give_credit(self); irttp_run_rx_queue()
1786 self->rx_queue_lock = 0; irttp_run_rx_queue()
1797 struct tsap_cb *self; irttp_seq_start() local
1803 for (self = (struct tsap_cb *) hashbin_get_first(irttp->tsaps); irttp_seq_start()
1804 self != NULL; irttp_seq_start()
1805 self = (struct tsap_cb *) hashbin_get_next(irttp->tsaps)) { irttp_seq_start()
1811 return self; irttp_seq_start()
1831 const struct tsap_cb *self = v; irttp_seq_show() local
1835 self->stsap_sel); irttp_seq_show()
1837 self->dtsap_sel); irttp_seq_show()
1839 self->connected ? "TRUE" : "FALSE"); irttp_seq_show()
1841 self->avail_credit); irttp_seq_show()
1843 self->remote_credit); irttp_seq_show()
1845 self->send_credit); irttp_seq_show()
1847 self->stats.tx_packets); irttp_seq_show()
1849 self->stats.rx_packets); irttp_seq_show()
1851 skb_queue_len(&self->tx_queue)); irttp_seq_show()
1853 skb_queue_len(&self->rx_queue)); irttp_seq_show()
1855 self->tx_sdu_busy ? "TRUE" : "FALSE"); irttp_seq_show()
1857 self->rx_sdu_busy ? "TRUE" : "FALSE"); irttp_seq_show()
1859 self->max_seg_size); irttp_seq_show()
1861 self->tx_max_sdu_size); irttp_seq_show()
1863 self->rx_max_sdu_size); irttp_seq_show()
1866 self->notify.name); irttp_seq_show()
|
| H A D | timer.c | 44 void irlap_start_slot_timer(struct irlap_cb *self, int timeout) irlap_start_slot_timer() argument
46 irda_start_timer(&self->slot_timer, timeout, (void *) self, irlap_start_slot_timer()
50 void irlap_start_query_timer(struct irlap_cb *self, int S, int s) irlap_start_query_timer() argument
69 irda_start_timer( &self->query_timer, timeout, (void *) self, irlap_start_query_timer()
73 void irlap_start_final_timer(struct irlap_cb *self, int timeout) irlap_start_final_timer() argument
75 irda_start_timer(&self->final_timer, timeout, (void *) self, irlap_start_final_timer()
79 void irlap_start_wd_timer(struct irlap_cb *self, int timeout) irlap_start_wd_timer() argument
81 irda_start_timer(&self->wd_timer, timeout, (void *) self, irlap_start_wd_timer()
85 void irlap_start_backoff_timer(struct irlap_cb *self, int timeout) irlap_start_backoff_timer() argument
87 irda_start_timer(&self->backoff_timer, timeout, (void *) self, irlap_start_backoff_timer()
91 void irlap_start_mbusy_timer(struct irlap_cb *self, int timeout) irlap_start_mbusy_timer() argument
93 irda_start_timer(&self->media_busy_timer, timeout, irlap_start_mbusy_timer()
94 (void *) self, irlap_media_busy_expired); irlap_start_mbusy_timer()
97 void irlap_stop_mbusy_timer(struct irlap_cb *self) irlap_stop_mbusy_timer() argument
100 del_timer(&self->media_busy_timer); irlap_stop_mbusy_timer()
107 if (self->state == LAP_NDM) irlap_stop_mbusy_timer()
108 irlap_do_event(self, MEDIA_BUSY_TIMER_EXPIRED, NULL, NULL); irlap_stop_mbusy_timer()
111 void irlmp_start_watchdog_timer(struct lsap_cb *self, int timeout) irlmp_start_watchdog_timer() argument
113 irda_start_timer(&self->watchdog_timer, timeout, (void *) self, irlmp_start_watchdog_timer()
117 void irlmp_start_discovery_timer(struct irlmp_cb *self, int timeout) irlmp_start_discovery_timer() argument
119 irda_start_timer(&self->discovery_timer, timeout, (void *) self, irlmp_start_discovery_timer()
123 void irlmp_start_idle_timer(struct lap_cb *self, int timeout) irlmp_start_idle_timer() argument
125 irda_start_timer(&self->idle_timer, timeout, (void *) self, irlmp_start_idle_timer()
129 void irlmp_stop_idle_timer(struct lap_cb *self) irlmp_stop_idle_timer() argument
132 del_timer(&self->idle_timer); irlmp_stop_idle_timer()
143 struct irlap_cb *self = (struct irlap_cb *) data; irlap_slot_timer_expired() local
145 IRDA_ASSERT(self != NULL, return;); irlap_slot_timer_expired()
146 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_slot_timer_expired()
148 irlap_do_event(self, SLOT_TIMER_EXPIRED, NULL, NULL); irlap_slot_timer_expired()
159 struct irlap_cb *self = (struct irlap_cb *) data; irlap_query_timer_expired() local
161 IRDA_ASSERT(self != NULL, return;); irlap_query_timer_expired()
162 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_query_timer_expired()
164 irlap_do_event(self, QUERY_TIMER_EXPIRED, NULL, NULL); irlap_query_timer_expired()
175 struct irlap_cb *self = (struct irlap_cb *) data; irlap_final_timer_expired() local
177 IRDA_ASSERT(self != NULL, return;); irlap_final_timer_expired()
178 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_final_timer_expired()
180 irlap_do_event(self, FINAL_TIMER_EXPIRED, NULL, NULL); irlap_final_timer_expired()
191 struct irlap_cb *self = (struct irlap_cb *) data; irlap_wd_timer_expired() local
193 IRDA_ASSERT(self != NULL, return;); irlap_wd_timer_expired()
194 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_wd_timer_expired()
196 irlap_do_event(self, WD_TIMER_EXPIRED, NULL, NULL); irlap_wd_timer_expired()
207 struct irlap_cb *self = (struct irlap_cb *) data; irlap_backoff_timer_expired() local
209 IRDA_ASSERT(self != NULL, return;); irlap_backoff_timer_expired()
210 IRDA_ASSERT(self->magic == LAP_MAGIC, return;); irlap_backoff_timer_expired()
212 irlap_do_event(self, BACKOFF_TIMER_EXPIRED, NULL, NULL); irlap_backoff_timer_expired()
223 struct irlap_cb *self = (struct irlap_cb *) data; irlap_media_busy_expired() local
225 IRDA_ASSERT(self != NULL, return;); irlap_media_busy_expired()
227 irda_device_set_media_busy(self->netdev, FALSE); irlap_media_busy_expired()
|
| H A D | irlmp_event.c | 117 static inline void irlmp_next_lap_state(struct lap_cb *self, irlmp_next_lap_state() argument
123 self->lap_state = state; irlmp_next_lap_state()
126 static inline void irlmp_next_lsap_state(struct lsap_cb *self, irlmp_next_lsap_state() argument
130 IRDA_ASSERT(self != NULL, return;); irlmp_next_lsap_state()
133 self->lsap_state = state; irlmp_next_lsap_state()
137 int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event, irlmp_do_lsap_event() argument
140 IRDA_ASSERT(self != NULL, return -1;); irlmp_do_lsap_event()
141 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_do_lsap_event()
144 __func__, irlmp_event[event], irlsap_state[self->lsap_state]); irlmp_do_lsap_event()
146 return (*lsap_state[self->lsap_state]) (self, event, skb); irlmp_do_lsap_event()
155 void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event, irlmp_do_lap_event() argument
158 IRDA_ASSERT(self != NULL, return;); irlmp_do_lap_event()
159 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_do_lap_event()
163 irlmp_state[self->lap_state]); irlmp_do_lap_event()
165 (*lap_state[self->lap_state]) (self, event, skb); irlmp_do_lap_event()
181 struct lsap_cb *self = (struct lsap_cb *) data; irlmp_watchdog_timer_expired() local
183 IRDA_ASSERT(self != NULL, return;); irlmp_watchdog_timer_expired()
184 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_watchdog_timer_expired()
186 irlmp_do_lsap_event(self, LM_WATCHDOG_TIMEOUT, NULL); irlmp_watchdog_timer_expired()
191 struct lap_cb *self = (struct lap_cb *) data; irlmp_idle_timer_expired() local
193 IRDA_ASSERT(self != NULL, return;); irlmp_idle_timer_expired()
194 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_idle_timer_expired()
196 irlmp_do_lap_event(self, LM_LAP_IDLE_TIMEOUT, NULL); irlmp_idle_timer_expired()
248 static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event, irlmp_state_standby() argument
251 IRDA_ASSERT(self->irlap != NULL, return;); irlmp_state_standby()
257 irlap_discovery_request(self->irlap, &irlmp->discovery_cmd); irlmp_state_standby()
264 irlmp_next_lap_state(self, LAP_ACTIVE); irlmp_state_standby()
267 irlap_connect_response(self->irlap, skb); irlmp_state_standby()
272 irlmp_next_lap_state(self, LAP_U_CONNECT); irlmp_state_standby()
275 irlap_connect_request(self->irlap, self->daddr, NULL, 0); irlmp_state_standby()
281 irlmp_next_lap_state(self, LAP_STANDBY); irlmp_state_standby()
297 static void irlmp_state_u_connect(struct lap_cb *self, IRLMP_EVENT event, irlmp_state_u_connect() argument
308 irlmp_next_lap_state(self, LAP_ACTIVE); irlmp_state_u_connect()
311 irlap_connect_response(self->irlap, skb); irlmp_state_u_connect()
314 irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM); irlmp_state_u_connect()
319 if (HASHBIN_GET_SIZE(self->lsaps) == 0) { irlmp_state_u_connect()
321 irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT); irlmp_state_u_connect()
329 irlmp_next_lap_state(self, LAP_ACTIVE); irlmp_state_u_connect()
332 irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM); irlmp_state_u_connect()
337 if (HASHBIN_GET_SIZE(self->lsaps) == 0) { irlmp_state_u_connect()
339 irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT); irlmp_state_u_connect()
344 irlmp_next_lap_state(self, LAP_STANDBY); irlmp_state_u_connect()
347 irlmp_do_all_lsap_event(self->lsaps, irlmp_state_u_connect()
355 if (HASHBIN_GET_SIZE(self->lsaps) <= 1) { irlmp_state_u_connect()
356 irlap_disconnect_request(self->irlap); irlmp_state_u_connect()
372 static void irlmp_state_active(struct lap_cb *self, IRLMP_EVENT event, irlmp_state_active() argument
385 irlap_clear_disconnect(self->irlap); irlmp_state_active()
393 irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM); irlmp_state_active()
407 if (HASHBIN_GET_SIZE(self->lsaps) > 0) { irlmp_state_active()
409 irlmp_start_idle_timer(self, sysctl_lap_keepalive_time * HZ / 1000); irlmp_state_active()
423 irlap_disconnect_request(self->irlap); irlmp_state_active()
427 if (HASHBIN_GET_SIZE(self->lsaps) == 0) { irlmp_state_active()
429 irlap_disconnect_request(self->irlap); irlmp_state_active()
433 irlmp_next_lap_state(self, LAP_STANDBY); irlmp_state_active()
441 irlmp_stop_idle_timer(self); irlmp_state_active()
446 irlmp_do_all_lsap_event(self->lsaps, irlmp_state_active()
477 static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event, irlmp_state_disconnected() argument
482 IRDA_ASSERT(self != NULL, return -1;); irlmp_state_disconnected()
483 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_state_disconnected()
491 irlmp_connless_data_indication(self, skb); irlmp_state_disconnected()
497 if (self->conn_skb) { irlmp_state_disconnected()
504 self->conn_skb = skb; irlmp_state_disconnected()
506 irlmp_next_lsap_state(self, LSAP_SETUP_PEND); irlmp_state_disconnected()
509 irlmp_start_watchdog_timer(self, 5*HZ); irlmp_state_disconnected()
511 irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL); irlmp_state_disconnected()
514 if (self->conn_skb) { irlmp_state_disconnected()
521 self->conn_skb = skb; irlmp_state_disconnected()
523 irlmp_next_lsap_state(self, LSAP_CONNECT_PEND); irlmp_state_disconnected()
536 irlmp_start_watchdog_timer(self, 1*HZ); irlmp_state_disconnected()
538 irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL); irlmp_state_disconnected()
542 __func__, irlmp_event[event], self->slsap_sel); irlmp_state_disconnected()
549 * Function irlmp_state_connect (self, event, skb)
554 static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event, irlmp_state_connect() argument
560 IRDA_ASSERT(self != NULL, return -1;); irlmp_state_connect()
561 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_state_connect()
569 lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, irlmp_state_connect()
572 IRDA_ASSERT(lsap == self, return -1;); irlmp_state_connect()
573 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_connect()
574 IRDA_ASSERT(self->lap->lsaps != NULL, return -1;); irlmp_state_connect()
576 hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, irlmp_state_connect()
577 (long) self, NULL); irlmp_state_connect()
579 set_bit(0, &self->connected); /* TRUE */ irlmp_state_connect()
581 irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, irlmp_state_connect()
582 self->slsap_sel, CONNECT_CNF, skb); irlmp_state_connect()
584 del_timer(&self->watchdog_timer); irlmp_state_connect()
586 irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY); irlmp_state_connect()
594 self->lap = NULL; irlmp_state_connect()
595 self->dlsap_sel = LSAP_ANY; irlmp_state_connect()
596 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_connect()
602 __func__, irlmp_event[event], self->slsap_sel); irlmp_state_connect()
614 static int irlmp_state_connect_pend(struct lsap_cb *self, IRLMP_EVENT event, irlmp_state_connect_pend() argument
620 IRDA_ASSERT(self != NULL, return -1;); irlmp_state_connect_pend()
621 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_state_connect_pend()
639 irlmp_next_lsap_state(self, LSAP_CONNECT); irlmp_state_connect_pend()
641 tx_skb = self->conn_skb; irlmp_state_connect_pend()
642 self->conn_skb = NULL; irlmp_state_connect_pend()
644 irlmp_connect_indication(self, tx_skb); irlmp_state_connect_pend()
655 self->lap = NULL; irlmp_state_connect_pend()
656 self->dlsap_sel = LSAP_ANY; irlmp_state_connect_pend()
657 if(self->conn_skb) irlmp_state_connect_pend()
658 dev_kfree_skb(self->conn_skb); irlmp_state_connect_pend()
659 self->conn_skb = NULL; irlmp_state_connect_pend()
660 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_connect_pend()
666 __func__, irlmp_event[event], self->slsap_sel); irlmp_state_connect_pend()
673 * Function irlmp_state_dtr (self, event, skb)
678 static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event, irlmp_state_dtr() argument
684 IRDA_ASSERT(self != NULL, return -1;); irlmp_state_dtr()
685 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_state_dtr()
686 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_dtr()
690 irlmp_send_data_pdu(self->lap, self->dlsap_sel, irlmp_state_dtr()
691 self->slsap_sel, FALSE, skb); irlmp_state_dtr()
694 irlmp_data_indication(self, skb); irlmp_state_dtr()
698 irlmp_send_data_pdu(self->lap, self->dlsap_sel, irlmp_state_dtr()
699 self->slsap_sel, TRUE, skb); irlmp_state_dtr()
702 irlmp_udata_indication(self, skb); irlmp_state_dtr()
715 irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, self->slsap_sel, irlmp_state_dtr()
717 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_dtr()
722 if (self->lap) { irlmp_state_dtr()
725 irlmp_do_lap_event(self->lap, irlmp_state_dtr()
731 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_dtr()
733 reason = irlmp_convert_lap_reason(self->lap->reason); irlmp_state_dtr()
735 irlmp_disconnect_indication(self, reason, NULL); irlmp_state_dtr()
738 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_dtr()
740 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_dtr()
741 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); irlmp_state_dtr()
749 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); irlmp_state_dtr()
751 irlmp_disconnect_indication(self, reason, skb); irlmp_state_dtr()
755 __func__, irlmp_event[event], self->slsap_sel); irlmp_state_dtr()
768 static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event, irlmp_state_setup() argument
774 IRDA_ASSERT(self != NULL, return -1;); irlmp_state_setup()
775 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_state_setup()
779 irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY); irlmp_state_setup()
781 del_timer(&self->watchdog_timer); irlmp_state_setup()
783 irlmp_connect_confirm(self, skb); irlmp_state_setup()
786 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_setup()
788 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_setup()
789 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); irlmp_state_setup()
797 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); irlmp_state_setup()
799 irlmp_disconnect_indication(self, reason, skb); irlmp_state_setup()
802 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_setup()
804 del_timer(&self->watchdog_timer); irlmp_state_setup()
806 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_setup()
807 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); irlmp_state_setup()
809 reason = irlmp_convert_lap_reason(self->lap->reason); irlmp_state_setup()
811 irlmp_disconnect_indication(self, reason, skb); irlmp_state_setup()
816 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_setup()
817 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); irlmp_state_setup()
818 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_setup()
820 irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL); irlmp_state_setup()
824 __func__, irlmp_event[event], self->slsap_sel); irlmp_state_setup()
838 static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event, irlmp_state_setup_pend() argument
845 IRDA_ASSERT(self != NULL, return -1;); irlmp_state_setup_pend()
850 IRDA_ASSERT(self->conn_skb != NULL, return -1;); irlmp_state_setup_pend()
852 tx_skb = self->conn_skb; irlmp_state_setup_pend()
853 self->conn_skb = NULL; irlmp_state_setup_pend()
855 irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, irlmp_state_setup_pend()
856 self->slsap_sel, CONNECT_CMD, tx_skb); irlmp_state_setup_pend()
860 irlmp_next_lsap_state(self, LSAP_SETUP); irlmp_state_setup_pend()
865 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_state_setup_pend()
866 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); irlmp_state_setup_pend()
867 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_setup_pend()
869 irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL); irlmp_state_setup_pend()
872 del_timer( &self->watchdog_timer); irlmp_state_setup_pend()
874 irlmp_next_lsap_state(self, LSAP_DISCONNECTED); irlmp_state_setup_pend()
876 reason = irlmp_convert_lap_reason(self->lap->reason); irlmp_state_setup_pend()
878 irlmp_disconnect_indication(self, reason, NULL); irlmp_state_setup_pend()
882 __func__, irlmp_event[event], self->slsap_sel); irlmp_state_setup_pend()
|
| H A D | iriap.c | 64 static void __iriap_close(struct iriap_cb *self);
65 static int iriap_register_lsap(struct iriap_cb *self, __u8 slsap_sel, int mode);
81 static inline void iriap_start_watchdog_timer(struct iriap_cb *self, iriap_start_watchdog_timer() argument
84 irda_start_timer(&self->watchdog_timer, timeout, self, iriap_start_watchdog_timer()
176 struct iriap_cb *self; iriap_open() local
178 self = kzalloc(sizeof(*self), GFP_ATOMIC); iriap_open()
179 if (!self) iriap_open()
186 self->magic = IAS_MAGIC; iriap_open()
187 self->mode = mode; iriap_open()
189 iriap_register_lsap(self, slsap_sel, mode); iriap_open()
191 self->confirm = callback; iriap_open()
192 self->priv = priv; iriap_open()
196 self->max_header_size = LMP_MAX_HEADER; iriap_open()
198 init_timer(&self->watchdog_timer); iriap_open()
200 hashbin_insert(iriap, (irda_queue_t *) self, (long) self, NULL); iriap_open()
203 iriap_next_client_state(self, S_DISCONNECT); iriap_open()
204 iriap_next_call_state(self, S_MAKE_CALL); iriap_open()
205 iriap_next_server_state(self, R_DISCONNECT); iriap_open()
206 iriap_next_r_connect_state(self, R_WAITING); iriap_open()
208 return self; iriap_open()
213 * Function __iriap_close (self)
218 static void __iriap_close(struct iriap_cb *self) __iriap_close() argument
220 IRDA_ASSERT(self != NULL, return;); __iriap_close()
221 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); __iriap_close()
223 del_timer(&self->watchdog_timer); __iriap_close()
225 if (self->request_skb) __iriap_close()
226 dev_kfree_skb(self->request_skb); __iriap_close()
228 self->magic = 0; __iriap_close()
230 kfree(self); __iriap_close()
238 void iriap_close(struct iriap_cb *self) iriap_close() argument
242 IRDA_ASSERT(self != NULL, return;); iriap_close()
243 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_close()
245 if (self->lsap) { iriap_close()
246 irlmp_close_lsap(self->lsap); iriap_close()
247 self->lsap = NULL; iriap_close()
250 entry = (struct iriap_cb *) hashbin_remove(iriap, (long) self, NULL); iriap_close()
251 IRDA_ASSERT(entry == self, return;); iriap_close()
253 __iriap_close(self); iriap_close()
257 static int iriap_register_lsap(struct iriap_cb *self, __u8 slsap_sel, int mode) iriap_register_lsap() argument
266 notify.instance = self; iriap_register_lsap()
272 self->lsap = irlmp_open_lsap(slsap_sel, ¬ify, 0); iriap_register_lsap()
273 if (self->lsap == NULL) { iriap_register_lsap()
278 self->slsap_sel = self->lsap->slsap_sel; iriap_register_lsap()
293 struct iriap_cb *self; iriap_disconnect_indication() local
298 self = instance; iriap_disconnect_indication()
300 IRDA_ASSERT(self != NULL, return;); iriap_disconnect_indication()
301 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_disconnect_indication()
305 del_timer(&self->watchdog_timer); iriap_disconnect_indication()
311 if (self->mode == IAS_CLIENT) { iriap_disconnect_indication()
315 iriap_do_client_event(self, IAP_LM_DISCONNECT_INDICATION, iriap_disconnect_indication()
320 * remember no to use self anymore after calling confirm iriap_disconnect_indication()
322 if (self->confirm) iriap_disconnect_indication()
323 self->confirm(IAS_DISCONNECT, 0, NULL, self->priv); iriap_disconnect_indication()
326 iriap_do_server_event(self, IAP_LM_DISCONNECT_INDICATION, iriap_disconnect_indication()
328 iriap_close(self); iriap_disconnect_indication()
335 static void iriap_disconnect_request(struct iriap_cb *self) iriap_disconnect_request() argument
339 IRDA_ASSERT(self != NULL, return;); iriap_disconnect_request()
340 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_disconnect_request()
354 irlmp_disconnect_request(self->lsap, tx_skb); iriap_disconnect_request()
363 int iriap_getvaluebyclass_request(struct iriap_cb *self, iriap_getvaluebyclass_request() argument
371 IRDA_ASSERT(self != NULL, return -1;); iriap_getvaluebyclass_request()
372 IRDA_ASSERT(self->magic == IAS_MAGIC, return -1;); iriap_getvaluebyclass_request()
378 self->daddr = daddr; iriap_getvaluebyclass_request()
379 self->saddr = saddr; iriap_getvaluebyclass_request()
384 self->operation = GET_VALUE_BY_CLASS; iriap_getvaluebyclass_request()
387 iriap_start_watchdog_timer(self, 10*HZ); iriap_getvaluebyclass_request()
392 skb_len = self->max_header_size+2+name_len+1+attr_len+4; iriap_getvaluebyclass_request()
398 skb_reserve(tx_skb, self->max_header_size); iriap_getvaluebyclass_request()
409 iriap_do_client_event(self, IAP_CALL_REQUEST_GVBC, tx_skb); iriap_getvaluebyclass_request()
419 * Function iriap_getvaluebyclass_confirm (self, skb)
425 static void iriap_getvaluebyclass_confirm(struct iriap_cb *self, iriap_getvaluebyclass_confirm() argument
438 IRDA_ASSERT(self != NULL, return;); iriap_getvaluebyclass_confirm()
439 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_getvaluebyclass_confirm()
492 iriap_disconnect_request(self); iriap_getvaluebyclass_confirm()
520 iriap_disconnect_request(self); iriap_getvaluebyclass_confirm()
522 /* Warning, the client might close us, so remember no to use self iriap_getvaluebyclass_confirm()
525 if (self->confirm) iriap_getvaluebyclass_confirm()
526 self->confirm(IAS_SUCCESS, obj_id, value, self->priv); iriap_getvaluebyclass_confirm()
539 static void iriap_getvaluebyclass_response(struct iriap_cb *self, iriap_getvaluebyclass_response() argument
550 IRDA_ASSERT(self != NULL, return;); iriap_getvaluebyclass_response()
551 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_getvaluebyclass_response()
563 tx_skb = alloc_skb(value->len + self->max_header_size + 32, iriap_getvaluebyclass_response()
569 skb_reserve(tx_skb, self->max_header_size); iriap_getvaluebyclass_response()
618 iriap_do_r_connect_event(self, IAP_CALL_RESPONSE, tx_skb); iriap_getvaluebyclass_response()
625 * Function iriap_getvaluebyclass_indication (self, skb)
630 static void iriap_getvaluebyclass_indication(struct iriap_cb *self, iriap_getvaluebyclass_indication() argument
642 IRDA_ASSERT(self != NULL, return;); iriap_getvaluebyclass_indication()
643 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_getvaluebyclass_indication()
668 iriap_getvaluebyclass_response(self, 0x1235, IAS_CLASS_UNKNOWN, iriap_getvaluebyclass_indication()
677 iriap_getvaluebyclass_response(self, obj->id, iriap_getvaluebyclass_indication()
684 iriap_getvaluebyclass_response(self, obj->id, IAS_SUCCESS, iriap_getvaluebyclass_indication()
694 void iriap_send_ack(struct iriap_cb *self) iriap_send_ack() argument
699 IRDA_ASSERT(self != NULL, return;); iriap_send_ack()
700 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_send_ack()
707 skb_reserve(tx_skb, self->max_header_size); iriap_send_ack()
712 frame[0] = IAP_LST | IAP_ACK | self->operation; iriap_send_ack()
714 irlmp_data_request(self->lsap, tx_skb); iriap_send_ack()
717 void iriap_connect_request(struct iriap_cb *self) iriap_connect_request() argument
721 IRDA_ASSERT(self != NULL, return;); iriap_connect_request()
722 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_connect_request()
724 ret = irlmp_connect_request(self->lsap, LSAP_IAS, iriap_connect_request()
725 self->saddr, self->daddr, iriap_connect_request()
729 self->confirm(IAS_DISCONNECT, 0, NULL, self->priv); iriap_connect_request()
744 struct iriap_cb *self; iriap_connect_confirm() local
746 self = instance; iriap_connect_confirm()
748 IRDA_ASSERT(self != NULL, return;); iriap_connect_confirm()
749 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_connect_confirm()
752 self->max_data_size = max_seg_size; iriap_connect_confirm()
753 self->max_header_size = max_header_size; iriap_connect_confirm()
755 del_timer(&self->watchdog_timer); iriap_connect_confirm()
757 iriap_do_client_event(self, IAP_LM_CONNECT_CONFIRM, skb); iriap_connect_confirm()
774 struct iriap_cb *self, *new; iriap_connect_indication() local
776 self = instance; iriap_connect_indication()
779 IRDA_ASSERT(self != NULL, goto out;); iriap_connect_indication()
780 IRDA_ASSERT(self->magic == IAS_MAGIC, goto out;); iriap_connect_indication()
790 new->lsap = irlmp_dup(self->lsap, new); iriap_connect_indication()
800 irlmp_listen(self->lsap); iriap_connect_indication()
818 struct iriap_cb *self; iriap_data_indication() local
822 self = instance; iriap_data_indication()
825 IRDA_ASSERT(self != NULL, goto out;); iriap_data_indication()
826 IRDA_ASSERT(self->magic == IAS_MAGIC, goto out;); iriap_data_indication()
830 if (self->mode == IAS_SERVER) { iriap_data_indication()
833 iriap_do_r_connect_event(self, IAP_RECV_F_LST, skb); iriap_data_indication()
856 iriap_do_call_event(self, IAP_RECV_F_LST, NULL); iriap_data_indication()
860 iriap_getvaluebyclass_confirm(self, skb); iriap_data_indication()
865 iriap_disconnect_request(self); iriap_data_indication()
869 * no to use self anymore after calling confirm iriap_data_indication()
871 if (self->confirm) iriap_data_indication()
872 self->confirm(IAS_CLASS_UNKNOWN, 0, NULL, iriap_data_indication()
873 self->priv); iriap_data_indication()
878 iriap_disconnect_request(self); iriap_data_indication()
882 * no to use self anymore after calling confirm iriap_data_indication()
884 if (self->confirm) iriap_data_indication()
885 self->confirm(IAS_ATTRIB_UNKNOWN, 0, NULL, iriap_data_indication()
886 self->priv); iriap_data_indication()
903 * Function iriap_call_indication (self, skb)
908 void iriap_call_indication(struct iriap_cb *self, struct sk_buff *skb) iriap_call_indication() argument
913 IRDA_ASSERT(self != NULL, return;); iriap_call_indication()
914 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_call_indication()
933 iriap_getvaluebyclass_indication(self, skb); iriap_call_indication()
947 struct iriap_cb *self = (struct iriap_cb *) data; iriap_watchdog_timer_expired() local
949 IRDA_ASSERT(self != NULL, return;); iriap_watchdog_timer_expired()
950 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); iriap_watchdog_timer_expired()
952 /* iriap_close(self); */ iriap_watchdog_timer_expired()
|
| H A D | af_irda.c | 83 struct irda_sock *self; irda_data_indication() local
87 self = instance; irda_data_indication()
93 self->rx_flow = FLOW_STOP; irda_data_indication()
111 struct irda_sock *self; irda_disconnect_indication() local
114 self = instance; irda_disconnect_indication()
116 pr_debug("%s(%p)\n", __func__, self); irda_disconnect_indication()
125 __func__, self); irda_disconnect_indication()
150 if (self->tsap) { irda_disconnect_indication()
151 irttp_close_tsap(self->tsap); irda_disconnect_indication()
152 self->tsap = NULL; irda_disconnect_indication()
176 struct irda_sock *self; irda_connect_confirm() local
179 self = instance; irda_connect_confirm()
181 pr_debug("%s(%p)\n", __func__, self); irda_connect_confirm()
193 self->max_header_size = max_header_size; irda_connect_confirm()
196 self->max_sdu_size_tx = max_sdu_size; irda_connect_confirm()
206 self->max_data_size = irttp_get_max_seg_size(self->tsap); irda_connect_confirm()
214 self->max_data_size = max_sdu_size; irda_connect_confirm()
217 self->max_data_size = irttp_get_max_seg_size(self->tsap); irda_connect_confirm()
221 self->max_data_size); irda_connect_confirm()
223 memcpy(&self->qos_tx, qos, sizeof(struct qos_info)); irda_connect_confirm()
240 struct irda_sock *self; irda_connect_indication() local
243 self = instance; irda_connect_indication()
245 pr_debug("%s(%p)\n", __func__, self); irda_connect_indication()
254 self->max_header_size = max_header_size; irda_connect_indication()
257 self->max_sdu_size_tx = max_sdu_size; irda_connect_indication()
268 self->max_data_size = irttp_get_max_seg_size(self->tsap); irda_connect_indication()
277 self->max_data_size = max_sdu_size; irda_connect_indication()
280 self->max_data_size = irttp_get_max_seg_size(self->tsap); irda_connect_indication()
284 self->max_data_size); irda_connect_indication()
286 memcpy(&self->qos_tx, qos, sizeof(struct qos_info)); irda_connect_indication()
298 static void irda_connect_response(struct irda_sock *self) irda_connect_response() argument
312 irttp_connect_response(self->tsap, self->max_sdu_size_rx, skb); irda_connect_response()
323 struct irda_sock *self; irda_flow_indication() local
326 self = instance; irda_flow_indication()
334 self->tx_flow = flow; irda_flow_indication()
337 self->tx_flow = flow; irda_flow_indication()
345 self->tx_flow = flow; irda_flow_indication()
361 struct irda_sock *self; irda_getvalue_confirm() local
363 self = priv; irda_getvalue_confirm()
364 if (!self) { irda_getvalue_confirm()
369 pr_debug("%s(%p)\n", __func__, self); irda_getvalue_confirm()
372 iriap_close(self->iriap); irda_getvalue_confirm()
373 self->iriap = NULL; irda_getvalue_confirm()
380 self->errno = result; /* We really need it later */ irda_getvalue_confirm()
383 wake_up_interruptible(&self->query_wait); irda_getvalue_confirm()
389 self->ias_result = value; irda_getvalue_confirm()
390 self->errno = 0; irda_getvalue_confirm()
393 wake_up_interruptible(&self->query_wait); irda_getvalue_confirm()
408 struct irda_sock *self; irda_selective_discovery_indication() local
410 self = priv; irda_selective_discovery_indication()
411 if (!self) { irda_selective_discovery_indication()
417 self->cachedaddr = discovery->daddr; irda_selective_discovery_indication()
420 wake_up_interruptible(&self->query_wait); irda_selective_discovery_indication()
433 struct irda_sock *self; irda_discovery_timeout() local
435 self = (struct irda_sock *) priv; irda_discovery_timeout()
436 BUG_ON(self == NULL); irda_discovery_timeout()
439 self->cachelog = NULL; irda_discovery_timeout()
440 self->cachedaddr = 0; irda_discovery_timeout()
441 self->errno = -ETIME; irda_discovery_timeout()
444 wake_up_interruptible(&self->query_wait); irda_discovery_timeout()
448 * Function irda_open_tsap (self)
453 static int irda_open_tsap(struct irda_sock *self, __u8 tsap_sel, char *name) irda_open_tsap() argument
457 if (self->tsap) { irda_open_tsap()
470 notify.instance = self; irda_open_tsap()
473 self->tsap = irttp_open_tsap(tsap_sel, DEFAULT_INITIAL_CREDIT, irda_open_tsap()
475 if (self->tsap == NULL) { irda_open_tsap()
481 self->stsap_sel = self->tsap->stsap_sel; irda_open_tsap()
487 * Function irda_open_lsap (self)
493 static int irda_open_lsap(struct irda_sock *self, int pid) irda_open_lsap() argument
497 if (self->lsap) { irda_open_lsap()
505 notify.instance = self; irda_open_lsap()
508 self->lsap = irlmp_open_lsap(LSAP_CONNLESS, ¬ify, pid); irda_open_lsap()
509 if (self->lsap == NULL) { irda_open_lsap()
519 * Function irda_find_lsap_sel (self, name)
529 static int irda_find_lsap_sel(struct irda_sock *self, char *name) irda_find_lsap_sel() argument
531 pr_debug("%s(%p, %s)\n", __func__, self, name); irda_find_lsap_sel()
533 if (self->iriap) { irda_find_lsap_sel()
539 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, irda_find_lsap_sel()
541 if(self->iriap == NULL) irda_find_lsap_sel()
545 self->errno = -EHOSTUNREACH; irda_find_lsap_sel()
548 iriap_getvaluebyclass_request(self->iriap, self->saddr, self->daddr, irda_find_lsap_sel()
552 if (wait_event_interruptible(self->query_wait, (self->iriap==NULL))) irda_find_lsap_sel()
557 if (self->errno) irda_find_lsap_sel()
560 if((self->errno == IAS_CLASS_UNKNOWN) || irda_find_lsap_sel()
561 (self->errno == IAS_ATTRIB_UNKNOWN)) irda_find_lsap_sel()
568 switch (self->ias_result->type) { irda_find_lsap_sel()
571 __func__, self->ias_result->t.integer); irda_find_lsap_sel()
573 if (self->ias_result->t.integer != -1) irda_find_lsap_sel()
574 self->dtsap_sel = self->ias_result->t.integer; irda_find_lsap_sel()
576 self->dtsap_sel = 0; irda_find_lsap_sel()
579 self->dtsap_sel = 0; irda_find_lsap_sel()
583 if (self->ias_result) irda_find_lsap_sel()
584 irias_delete_value(self->ias_result); irda_find_lsap_sel()
586 if (self->dtsap_sel) irda_find_lsap_sel()
593 * Function irda_discover_daddr_and_lsap_sel (self, name)
609 static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name) irda_discover_daddr_and_lsap_sel() argument
624 discoveries = irlmp_get_discoveries(&number, self->mask.word, irda_discover_daddr_and_lsap_sel()
625 self->nslots); irda_discover_daddr_and_lsap_sel()
637 self->daddr = discoveries[i].daddr; irda_discover_daddr_and_lsap_sel()
638 self->saddr = 0x0; irda_discover_daddr_and_lsap_sel()
640 __func__, self->daddr); irda_discover_daddr_and_lsap_sel()
643 err = irda_find_lsap_sel(self, name); irda_discover_daddr_and_lsap_sel()
650 self->daddr = DEV_ADDR_ANY; irda_discover_daddr_and_lsap_sel()
655 daddr = self->daddr; irda_discover_daddr_and_lsap_sel()
656 dtsap_sel = self->dtsap_sel; irda_discover_daddr_and_lsap_sel()
665 self->daddr = DEV_ADDR_ANY; irda_discover_daddr_and_lsap_sel()
677 self->daddr = DEV_ADDR_ANY; irda_discover_daddr_and_lsap_sel()
682 self->daddr = daddr; irda_discover_daddr_and_lsap_sel()
683 self->saddr = 0x0; irda_discover_daddr_and_lsap_sel()
684 self->dtsap_sel = dtsap_sel; irda_discover_daddr_and_lsap_sel()
687 __func__, name, self->daddr); irda_discover_daddr_and_lsap_sel()
703 struct irda_sock *self = irda_sk(sk); irda_getname() local
711 saddr.sir_lsap_sel = self->dtsap_sel; irda_getname()
712 saddr.sir_addr = self->daddr; irda_getname()
715 saddr.sir_lsap_sel = self->stsap_sel; irda_getname()
716 saddr.sir_addr = self->saddr; irda_getname()
768 struct irda_sock *self = irda_sk(sk); irda_bind() local
771 pr_debug("%s(%p)\n", __func__, self); irda_bind()
781 self->pid = addr->sir_lsap_sel; irda_bind()
783 if (self->pid & 0x80) { irda_bind()
788 err = irda_open_lsap(self, self->pid); irda_bind()
801 self->ias_obj = irias_new_object(addr->sir_name, jiffies); irda_bind()
803 if (self->ias_obj == NULL) irda_bind()
806 err = irda_open_tsap(self, addr->sir_lsap_sel, addr->sir_name); irda_bind()
808 irias_delete_object(self->ias_obj); irda_bind()
809 self->ias_obj = NULL; irda_bind()
814 irias_add_integer_attrib(self->ias_obj, "IrDA:TinyTP:LsapSel", irda_bind()
815 self->stsap_sel, IAS_KERNEL_ATTR); irda_bind()
816 irias_insert_object(self->ias_obj); irda_bind()
833 struct irda_sock *new, *self = irda_sk(sk); irda_accept() local
899 new->tsap = irttp_dup(self->tsap, new); irda_accept()
912 new->max_sdu_size_tx = self->max_sdu_size_tx; irda_accept()
913 new->max_sdu_size_rx = self->max_sdu_size_rx; irda_accept()
914 new->max_data_size = self->max_data_size; irda_accept()
915 new->max_header_size = self->max_header_size; irda_accept()
917 memcpy(&new->qos_tx, &self->qos_tx, sizeof(struct qos_info)); irda_accept()
920 irttp_listen(self->tsap); irda_accept()
959 struct irda_sock *self = irda_sk(sk); irda_connect() local
962 pr_debug("%s(%p)\n", __func__, self); irda_connect()
996 err = irda_discover_daddr_and_lsap_sel(self, addr->sir_name); irda_connect()
1003 self->daddr = addr->sir_addr; irda_connect()
1004 pr_debug("%s(), daddr = %08x\n", __func__, self->daddr); irda_connect()
1012 err = irda_find_lsap_sel(self, addr->sir_name); irda_connect()
1022 self->dtsap_sel = addr->sir_lsap_sel; irda_connect()
1027 if (!self->tsap) irda_connect()
1028 irda_open_tsap(self, LSAP_ANY, addr->sir_name); irda_connect()
1035 err = irttp_connect_request(self->tsap, self->dtsap_sel, irda_connect()
1036 self->saddr, self->daddr, NULL, irda_connect()
1037 self->max_sdu_size_rx, NULL); irda_connect()
1064 self->saddr = irttp_get_saddr(self->tsap); irda_connect()
1087 struct irda_sock *self; irda_create() local
1110 self = irda_sk(sk); irda_create()
1111 pr_debug("%s() : self is %p\n", __func__, self); irda_create()
1113 init_waitqueue_head(&self->query_wait); irda_create()
1118 self->max_sdu_size_rx = TTP_SAR_DISABLE; irda_create()
1122 self->max_sdu_size_rx = TTP_SAR_UNBOUND; irda_create()
1131 self->max_data_size = ULTRA_MAX_DATA - LMP_PID_HEADER; irda_create()
1132 self->max_header_size = IRDA_MAX_HEADER + LMP_PID_HEADER; irda_create()
1138 self->max_sdu_size_rx = TTP_SAR_UNBOUND; irda_create()
1156 self->ckey = irlmp_register_client(0, NULL, NULL, NULL); irda_create()
1157 self->mask.word = 0xffff; irda_create()
1158 self->rx_flow = self->tx_flow = FLOW_START; irda_create()
1159 self->nslots = DISCOVERY_DEFAULT_SLOTS; irda_create()
1160 self->daddr = DEV_ADDR_ANY; /* Until we get connected */ irda_create()
1161 self->saddr = 0x0; /* so IrLMP assign us any link */ irda_create()
1166 * Function irda_destroy_socket (self)
1171 static void irda_destroy_socket(struct irda_sock *self) irda_destroy_socket() argument
1173 pr_debug("%s(%p)\n", __func__, self); irda_destroy_socket()
1176 irlmp_unregister_client(self->ckey); irda_destroy_socket()
1177 irlmp_unregister_service(self->skey); irda_destroy_socket()
1180 if (self->ias_obj) { irda_destroy_socket()
1181 irias_delete_object(self->ias_obj); irda_destroy_socket()
1182 self->ias_obj = NULL; irda_destroy_socket()
1185 if (self->iriap) { irda_destroy_socket()
1186 iriap_close(self->iriap); irda_destroy_socket()
1187 self->iriap = NULL; irda_destroy_socket()
1190 if (self->tsap) { irda_destroy_socket()
1191 irttp_disconnect_request(self->tsap, NULL, P_NORMAL); irda_destroy_socket()
1192 irttp_close_tsap(self->tsap); irda_destroy_socket()
1193 self->tsap = NULL; irda_destroy_socket()
1196 if (self->lsap) { irda_destroy_socket()
1197 irlmp_close_lsap(self->lsap); irda_destroy_socket()
1198 self->lsap = NULL; irda_destroy_socket()
1239 * because we close iriap and kfree(self) above. irda_release()
1242 * Same stuff as above, irlmp registration and self are gone. irda_release()
1271 struct irda_sock *self; irda_sendmsg() local
1293 self = irda_sk(sk); irda_sendmsg()
1298 (self->tx_flow != FLOW_STOP || sk->sk_state != TCP_ESTABLISHED))) { irda_sendmsg()
1310 if (len > self->max_data_size) { irda_sendmsg()
1312 __func__, len, self->max_data_size); irda_sendmsg()
1313 len = self->max_data_size; irda_sendmsg()
1316 skb = sock_alloc_send_skb(sk, len + self->max_header_size + 16, irda_sendmsg()
1321 skb_reserve(skb, self->max_header_size + 16); irda_sendmsg()
1334 err = irttp_data_request(self->tsap, skb); irda_sendmsg()
1362 struct irda_sock *self = irda_sk(sk); irda_recvmsg_dgram() local
1391 if (self->rx_flow == FLOW_STOP) { irda_recvmsg_dgram()
1394 self->rx_flow = FLOW_START; irda_recvmsg_dgram()
1395 irttp_flow_request(self->tsap, FLOW_START); irda_recvmsg_dgram()
1409 struct irda_sock *self = irda_sk(sk); irda_recvmsg_stream() local
1508 if (self->rx_flow == FLOW_STOP) { irda_recvmsg_stream()
1511 self->rx_flow = FLOW_START; irda_recvmsg_stream()
1512 irttp_flow_request(self->tsap, FLOW_START); irda_recvmsg_stream()
1530 struct irda_sock *self; irda_sendmsg_dgram() local
1551 self = irda_sk(sk); irda_sendmsg_dgram()
1557 if (len > self->max_data_size) { irda_sendmsg_dgram()
1559 __func__, len, self->max_data_size); irda_sendmsg_dgram()
1560 len = self->max_data_size; irda_sendmsg_dgram()
1563 skb = sock_alloc_send_skb(sk, len + self->max_header_size, irda_sendmsg_dgram()
1569 skb_reserve(skb, self->max_header_size); irda_sendmsg_dgram()
1584 err = irttp_udata_request(self->tsap, skb); irda_sendmsg_dgram()
1609 struct irda_sock *self; irda_sendmsg_ultra() local
1629 self = irda_sk(sk); irda_sendmsg_ultra()
1651 if ((self->lsap == NULL) || irda_sendmsg_ultra()
1666 if (len > self->max_data_size) { irda_sendmsg_ultra()
1668 __func__, len, self->max_data_size); irda_sendmsg_ultra()
1669 len = self->max_data_size; irda_sendmsg_ultra()
1672 skb = sock_alloc_send_skb(sk, len + self->max_header_size, irda_sendmsg_ultra()
1678 skb_reserve(skb, self->max_header_size); irda_sendmsg_ultra()
1689 err = irlmp_connless_data_request((bound ? self->lsap : NULL), irda_sendmsg_ultra()
1705 struct irda_sock *self = irda_sk(sk); irda_shutdown() local
1707 pr_debug("%s(%p)\n", __func__, self); irda_shutdown()
1715 if (self->iriap) { irda_shutdown()
1716 iriap_close(self->iriap); irda_shutdown()
1717 self->iriap = NULL; irda_shutdown()
1720 if (self->tsap) { irda_shutdown()
1721 irttp_disconnect_request(self->tsap, NULL, P_NORMAL); irda_shutdown()
1722 irttp_close_tsap(self->tsap); irda_shutdown()
1723 self->tsap = NULL; irda_shutdown()
1727 self->rx_flow = self->tx_flow = FLOW_START; /* needed ??? */ irda_shutdown()
1728 self->daddr = DEV_ADDR_ANY; /* Until we get re-connected */ irda_shutdown()
1729 self->saddr = 0x0; /* so IrLMP assign us any link */ irda_shutdown()
1743 struct irda_sock *self = irda_sk(sk); irda_poll() local
1772 if ((self->tx_flow == FLOW_START) && irda_poll()
1780 if ((self->tx_flow == FLOW_START) && irda_poll()
1876 struct irda_sock *self = irda_sk(sk); irda_setsockopt() local
1882 pr_debug("%s(%p)\n", __func__, self); irda_setsockopt()
1921 if(self->ias_obj == NULL) { irda_setsockopt()
1926 ias_obj = self->ias_obj; irda_setsockopt()
1934 ((ias_obj == NULL) || (ias_obj != self->ias_obj))) { irda_setsockopt()
2052 ias_obj = self->ias_obj; irda_setsockopt()
2065 ((ias_obj == NULL) || (ias_obj != self->ias_obj))) { irda_setsockopt()
2108 self->max_sdu_size_rx = opt; irda_setsockopt()
2129 if (self->skey) irda_setsockopt()
2130 irlmp_unregister_service(self->skey); irda_setsockopt()
2132 self->skey = irlmp_register_service((__u16) opt); irda_setsockopt()
2152 self->mask.word = (__u16) opt; irda_setsockopt()
2154 self->mask.word &= 0x7f7f; irda_setsockopt()
2156 if(!self->mask.word) irda_setsockopt()
2157 self->mask.word = 0xFFFF; irda_setsockopt()
2227 struct irda_sock *self = irda_sk(sk); irda_getsockopt() local
2239 pr_debug("%s(%p)\n", __func__, self); irda_getsockopt()
2265 discoveries = irlmp_get_discoveries(&list.len, self->mask.word, irda_getsockopt()
2266 self->nslots); irda_getsockopt()
2296 val = self->max_data_size; irda_getsockopt()
2338 ias_obj = self->ias_obj; irda_getsockopt()
2406 if(self->daddr != DEV_ADDR_ANY) { irda_getsockopt()
2408 daddr = self->daddr; irda_getsockopt()
2421 if (self->iriap) { irda_getsockopt()
2429 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, irda_getsockopt()
2432 if (self->iriap == NULL) { irda_getsockopt()
2439 self->errno = -EHOSTUNREACH; irda_getsockopt()
2442 iriap_getvaluebyclass_request(self->iriap, irda_getsockopt()
2443 self->saddr, daddr, irda_getsockopt()
2448 if (wait_event_interruptible(self->query_wait, irda_getsockopt()
2449 (self->iriap == NULL))) { irda_getsockopt()
2459 if (self->errno) irda_getsockopt()
2463 if((self->errno == IAS_CLASS_UNKNOWN) || irda_getsockopt()
2464 (self->errno == IAS_ATTRIB_UNKNOWN)) irda_getsockopt()
2473 err = irda_extract_ias_value(ias_opt, self->ias_result); irda_getsockopt()
2474 if (self->ias_result) irda_getsockopt()
2475 irias_delete_value(self->ias_result); irda_getsockopt()
2518 irlmp_update_client(self->ckey, self->mask.word, irda_getsockopt()
2520 NULL, (void *) self); irda_getsockopt()
2523 irlmp_discovery_request(self->nslots); irda_getsockopt()
2526 if (!self->cachedaddr) { irda_getsockopt()
2531 self->errno = 0; irda_getsockopt()
2532 setup_timer(&self->watchdog, irda_discovery_timeout, irda_getsockopt()
2533 (unsigned long)self); irda_getsockopt()
2534 mod_timer(&self->watchdog, irda_getsockopt()
2538 err = __wait_event_interruptible(self->query_wait, irda_getsockopt()
2539 (self->cachedaddr != 0 || self->errno == -ETIME)); irda_getsockopt()
2542 del_timer(&(self->watchdog)); irda_getsockopt()
2554 irlmp_update_client(self->ckey, self->mask.word, irda_getsockopt()
2558 if (!self->cachedaddr) { irda_getsockopt()
2562 daddr = self->cachedaddr; irda_getsockopt()
2564 self->cachedaddr = 0; irda_getsockopt()
|
| H A D | irlmp.c | 155 struct lsap_cb *self; irlmp_open_lsap() local
171 self = kzalloc(sizeof(struct lsap_cb), GFP_ATOMIC); irlmp_open_lsap()
172 if (self == NULL) irlmp_open_lsap()
175 self->magic = LMP_LSAP_MAGIC; irlmp_open_lsap()
176 self->slsap_sel = slsap_sel; irlmp_open_lsap()
181 self->dlsap_sel = LSAP_CONNLESS; irlmp_open_lsap()
182 self->pid = pid; irlmp_open_lsap()
185 self->dlsap_sel = LSAP_ANY; irlmp_open_lsap()
186 /* self->connected = FALSE; -> already NULL via memset() */ irlmp_open_lsap()
188 init_timer(&self->watchdog_timer); irlmp_open_lsap()
190 self->notify = *notify; irlmp_open_lsap()
192 self->lsap_state = LSAP_DISCONNECTED; irlmp_open_lsap()
195 hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, irlmp_open_lsap()
196 (long) self, NULL); irlmp_open_lsap()
198 return self; irlmp_open_lsap()
203 * Function __irlmp_close_lsap (self)
207 static void __irlmp_close_lsap(struct lsap_cb *self) __irlmp_close_lsap() argument
209 IRDA_ASSERT(self != NULL, return;); __irlmp_close_lsap()
210 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); __irlmp_close_lsap()
215 self->magic = 0; __irlmp_close_lsap()
216 del_timer(&self->watchdog_timer); /* Important! */ __irlmp_close_lsap()
218 if (self->conn_skb) __irlmp_close_lsap()
219 dev_kfree_skb(self->conn_skb); __irlmp_close_lsap()
221 kfree(self); __irlmp_close_lsap()
225 * Function irlmp_close_lsap (self)
230 void irlmp_close_lsap(struct lsap_cb *self) irlmp_close_lsap() argument
235 IRDA_ASSERT(self != NULL, return;); irlmp_close_lsap()
236 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_close_lsap()
242 lap = self->lap; irlmp_close_lsap()
249 if(self->lsap_state != LSAP_DISCONNECTED) { irlmp_close_lsap()
250 self->lsap_state = LSAP_DISCONNECTED; irlmp_close_lsap()
251 irlmp_do_lap_event(self->lap, irlmp_close_lsap()
255 lsap = hashbin_remove(lap->lsaps, (long) self, NULL); irlmp_close_lsap()
260 self->lap = NULL; irlmp_close_lsap()
263 lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, irlmp_close_lsap()
271 __irlmp_close_lsap(self); irlmp_close_lsap()
368 int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel, irlmp_connect_request() argument
377 IRDA_ASSERT(self != NULL, return -EBADR;); irlmp_connect_request()
378 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;); irlmp_connect_request()
381 __func__, self->slsap_sel, dlsap_sel, saddr, daddr); irlmp_connect_request()
383 if (test_bit(0, &self->connected)) { irlmp_connect_request()
407 self->dlsap_sel = dlsap_sel; irlmp_connect_request()
466 self->lap = lap; irlmp_connect_request()
472 lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL); irlmp_connect_request()
479 hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (long) self, irlmp_connect_request()
482 set_bit(0, &self->connected); /* TRUE */ irlmp_connect_request()
488 self->qos = *qos; irlmp_connect_request()
490 irlmp_do_lsap_event(self, LM_CONNECT_REQUEST, tx_skb); irlmp_connect_request()
506 * Function irlmp_connect_indication (self)
511 void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb) irlmp_connect_indication() argument
517 IRDA_ASSERT(self != NULL, return;); irlmp_connect_indication()
518 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_connect_indication()
520 IRDA_ASSERT(self->lap != NULL, return;); irlmp_connect_indication()
523 __func__, self->slsap_sel, self->dlsap_sel); irlmp_connect_indication()
525 /* Note : self->lap is set in irlmp_link_data_indication(), irlmp_connect_indication()
527 * Similarly, self->dlsap_sel is usually set in irlmp_find_lsap(). irlmp_connect_indication()
530 self->qos = *self->lap->qos; irlmp_connect_indication()
532 max_seg_size = self->lap->qos->data_size.value-LMP_HEADER; irlmp_connect_indication()
533 lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap); irlmp_connect_indication()
539 if (self->notify.connect_indication) { irlmp_connect_indication()
542 self->notify.connect_indication(self->notify.instance, self, irlmp_connect_indication()
543 &self->qos, max_seg_size, irlmp_connect_indication()
554 int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata) irlmp_connect_response() argument
556 IRDA_ASSERT(self != NULL, return -1;); irlmp_connect_response()
557 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_connect_response()
564 __func__, self->slsap_sel, self->dlsap_sel); irlmp_connect_response()
570 irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata); irlmp_connect_response()
584 void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb) irlmp_connect_confirm() argument
591 IRDA_ASSERT(self != NULL, return;); irlmp_connect_confirm()
592 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_connect_confirm()
593 IRDA_ASSERT(self->lap != NULL, return;); irlmp_connect_confirm()
595 self->qos = *self->lap->qos; irlmp_connect_confirm()
597 max_seg_size = self->lap->qos->data_size.value-LMP_HEADER; irlmp_connect_confirm()
598 lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap); irlmp_connect_confirm()
607 if (self->notify.connect_confirm) { irlmp_connect_confirm()
610 self->notify.connect_confirm(self->notify.instance, self, irlmp_connect_confirm()
611 &self->qos, max_seg_size, irlmp_connect_confirm()
677 int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata) irlmp_disconnect_request() argument
681 IRDA_ASSERT(self != NULL, return -1;); irlmp_disconnect_request()
682 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_disconnect_request()
689 if (! test_and_clear_bit(0, &self->connected)) { irlmp_disconnect_request()
701 irlmp_do_lsap_event(self, LM_DISCONNECT_REQUEST, userdata); irlmp_disconnect_request()
710 IRDA_ASSERT(self->lap != NULL, return -1;); irlmp_disconnect_request()
711 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); irlmp_disconnect_request()
712 IRDA_ASSERT(self->lap->lsaps != NULL, return -1;); irlmp_disconnect_request()
714 lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL); irlmp_disconnect_request()
716 self->lap->cache.valid = FALSE; irlmp_disconnect_request()
721 IRDA_ASSERT(lsap == self, return -1;); irlmp_disconnect_request()
723 hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, irlmp_disconnect_request()
724 (long) self, NULL); irlmp_disconnect_request()
727 self->dlsap_sel = LSAP_ANY; irlmp_disconnect_request()
728 self->lap = NULL; irlmp_disconnect_request()
739 void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason, irlmp_disconnect_indication() argument
746 IRDA_ASSERT(self != NULL, return;); irlmp_disconnect_indication()
747 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_disconnect_indication()
750 __func__, self->slsap_sel, self->dlsap_sel); irlmp_disconnect_indication()
756 if (! test_and_clear_bit(0, &self->connected)) { irlmp_disconnect_indication()
764 IRDA_ASSERT(self->lap != NULL, return;); irlmp_disconnect_indication()
765 IRDA_ASSERT(self->lap->lsaps != NULL, return;); irlmp_disconnect_indication()
767 lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL); irlmp_disconnect_indication()
769 self->lap->cache.valid = FALSE; irlmp_disconnect_indication()
773 IRDA_ASSERT(lsap == self, return;); irlmp_disconnect_indication()
777 self->dlsap_sel = LSAP_ANY; irlmp_disconnect_indication()
778 self->lap = NULL; irlmp_disconnect_indication()
783 if (self->notify.disconnect_indication) { irlmp_disconnect_indication()
787 self->notify.disconnect_indication(self->notify.instance, irlmp_disconnect_indication()
788 self, reason, skb); irlmp_disconnect_indication()
999 * Function irlmp_discovery_confirm ( self, log)
1094 * Function irlmp_data_request (self, skb)
1106 int irlmp_data_request(struct lsap_cb *self, struct sk_buff *userdata) irlmp_data_request() argument
1110 IRDA_ASSERT(self != NULL, return -1;); irlmp_data_request()
1111 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); irlmp_data_request()
1117 ret = irlmp_do_lsap_event(self, LM_DATA_REQUEST, userdata); irlmp_data_request()
1132 void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb) irlmp_data_indication() argument
1137 if (self->notify.data_indication) { irlmp_data_indication()
1140 self->notify.data_indication(self->notify.instance, self, skb); irlmp_data_indication()
1145 * Function irlmp_udata_request (self, skb)
1147 int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *userdata) irlmp_udata_request() argument
1157 ret = irlmp_do_lsap_event(self, LM_UDATA_REQUEST, userdata); irlmp_udata_request()
1166 * Function irlmp_udata_indication (self, skb)
1171 void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb) irlmp_udata_indication() argument
1173 IRDA_ASSERT(self != NULL, return;); irlmp_udata_indication()
1174 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_udata_indication()
1180 if (self->notify.udata_indication) { irlmp_udata_indication()
1183 self->notify.udata_indication(self->notify.instance, self, irlmp_udata_indication()
1189 * Function irlmp_connless_data_request (self, skb)
1192 int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata, irlmp_connless_data_request() argument
1206 if(self != NULL) irlmp_connless_data_request()
1207 userdata->data[0] = self->pid; irlmp_connless_data_request()
1239 * Function irlmp_connless_data_indication (self, skb)
1245 void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb) irlmp_connless_data_indication() argument
1247 IRDA_ASSERT(self != NULL, return;); irlmp_connless_data_indication()
1248 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); irlmp_connless_data_indication()
1254 if (self->notify.udata_indication) { irlmp_connless_data_indication()
1257 self->notify.udata_indication(self->notify.instance, self, irlmp_connless_data_indication()
1270 void irlmp_status_indication(struct lap_cb *self, irlmp_status_indication() argument
1277 curr = (struct lsap_cb *) hashbin_get_first( self->lsaps); irlmp_status_indication()
1278 while (NULL != hashbin_find_next(self->lsaps, (long) curr, NULL, irlmp_status_indication()
1304 void irlmp_flow_indication(struct lap_cb *self, LOCAL_FLOW flow) irlmp_flow_indication() argument
1310 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_flow_indication()
1315 lsap_todo = HASHBIN_GET_SIZE(self->lsaps); irlmp_flow_indication()
1323 (IRLAP_GET_TX_QUEUE_LEN(self->irlap) < LAP_HIGH_THRESHOLD)) { irlmp_flow_indication()
1325 next = self->flow_next; irlmp_flow_indication()
1328 next = (struct lsap_cb *) hashbin_get_first(self->lsaps); irlmp_flow_indication()
1330 curr = hashbin_find_next(self->lsaps, (long) next, NULL, irlmp_flow_indication()
1331 (void *) &self->flow_next); irlmp_flow_indication()
1336 __func__, curr, next, self->flow_next, lsap_todo, irlmp_flow_indication()
1337 IRLAP_GET_TX_QUEUE_LEN(self->irlap)); irlmp_flow_indication()
1631 struct lsap_cb *self; irlmp_slsap_inuse() local
1666 self = (struct lsap_cb *) hashbin_get_first(lap->lsaps); irlmp_slsap_inuse()
1667 while (self != NULL) { irlmp_slsap_inuse()
1668 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, irlmp_slsap_inuse()
1671 if ((self->slsap_sel == slsap_sel)) { irlmp_slsap_inuse()
1673 self->slsap_sel); irlmp_slsap_inuse()
1676 self = (struct lsap_cb*) hashbin_get_next(lap->lsaps); irlmp_slsap_inuse()
1693 self = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps); irlmp_slsap_inuse()
1694 while (self != NULL) { irlmp_slsap_inuse()
1695 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, goto erruncon;); irlmp_slsap_inuse()
1696 if ((self->slsap_sel == slsap_sel)) { irlmp_slsap_inuse()
1698 self->slsap_sel); irlmp_slsap_inuse()
1701 self = (struct lsap_cb*) hashbin_get_next(irlmp->unconnected_lsaps); irlmp_slsap_inuse()
1916 struct lsap_cb *self = v; irlmp_seq_show() local
1923 self = v; irlmp_seq_show()
1924 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EINVAL; ); irlmp_seq_show()
1926 irlsap_state[ self->lsap_state]); irlmp_seq_show()
1929 self->slsap_sel, self->dlsap_sel); irlmp_seq_show()
1930 seq_printf(seq, "(%s)", self->notify.name); irlmp_seq_show()
1950 for (self = (struct lsap_cb *) hashbin_get_first(lap->lsaps); irlmp_seq_show()
1951 self != NULL; irlmp_seq_show()
1952 self = (struct lsap_cb *)hashbin_get_next(lap->lsaps)) { irlmp_seq_show()
1953 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, irlmp_seq_show()
1956 irlsap_state[ self->lsap_state]); irlmp_seq_show()
1959 self->slsap_sel, self->dlsap_sel); irlmp_seq_show()
1960 seq_printf(seq, "(%s)", self->notify.name); irlmp_seq_show()
|
| H A D | irlmp_frame.c | 37 static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap,
40 inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap, irlmp_send_data_pdu() argument
48 irlap_data_request(self->irlap, skb, TRUE); irlmp_send_data_pdu()
50 irlap_data_request(self->irlap, skb, FALSE); irlmp_send_data_pdu()
58 void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap, irlmp_send_lcf_pdu() argument
63 IRDA_ASSERT(self != NULL, return;); irlmp_send_lcf_pdu()
64 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_send_lcf_pdu()
79 irlap_data_request(self->irlap, skb, FALSE); irlmp_send_lcf_pdu()
88 void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb, irlmp_link_data_indication() argument
96 IRDA_ASSERT(self != NULL, return;); irlmp_link_data_indication()
97 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_link_data_indication()
118 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD, irlmp_link_data_indication()
125 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0, irlmp_link_data_indication()
126 self->lsaps); irlmp_link_data_indication()
129 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0, irlmp_link_data_indication()
130 self->lsaps); irlmp_link_data_indication()
151 lsap->lap = self; irlmp_link_data_indication()
190 * Function irlmp_link_unitdata_indication (self, skb)
196 void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb) irlmp_link_unitdata_indication() argument
205 IRDA_ASSERT(self != NULL, return;); irlmp_link_unitdata_indication()
206 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_link_unitdata_indication()
287 void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr, irlmp_link_connect_indication() argument
292 self->qos = qos; irlmp_link_connect_indication()
295 self->daddr = daddr; irlmp_link_connect_indication()
296 IRDA_ASSERT(self->saddr == saddr, return;); irlmp_link_connect_indication()
298 irlmp_do_lap_event(self, LM_LAP_CONNECT_INDICATION, skb); irlmp_link_connect_indication()
307 void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos, irlmp_link_connect_confirm() argument
310 IRDA_ASSERT(self != NULL, return;); irlmp_link_connect_confirm()
311 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_link_connect_confirm()
317 self->qos = qos; irlmp_link_connect_confirm()
319 irlmp_do_lap_event(self, LM_LAP_CONNECT_CONFIRM, NULL); irlmp_link_connect_confirm()
323 * Function irlmp_link_discovery_indication (self, log)
350 void irlmp_link_discovery_indication(struct lap_cb *self, irlmp_link_discovery_indication() argument
353 IRDA_ASSERT(self != NULL, return;); irlmp_link_discovery_indication()
354 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_link_discovery_indication()
365 * Function irlmp_link_discovery_confirm (self, log)
372 void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log) irlmp_link_discovery_confirm() argument
374 IRDA_ASSERT(self != NULL, return;); irlmp_link_discovery_confirm()
375 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); irlmp_link_discovery_confirm()
404 * Function irlmp_find_handle (self, dlsap_sel, slsap_sel, status, queue)
420 static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel, irlmp_find_lsap() argument
433 if ((self->cache.valid) && irlmp_find_lsap()
434 (self->cache.slsap_sel == slsap_sel) && irlmp_find_lsap()
435 (self->cache.dlsap_sel == dlsap_sel)) irlmp_find_lsap()
437 return self->cache.lsap; irlmp_find_lsap()
470 irlmp_update_cache(self, lsap); irlmp_find_lsap()
|
| H A D | qos.c | 427 int irlap_qos_negotiate(struct irlap_cb *self, struct sk_buff *skb) irlap_qos_negotiate() argument
431 ret = irda_param_extract_all(self, skb->data, skb->len, irlap_qos_negotiate()
435 irda_qos_bits_to_value(&self->qos_tx); irlap_qos_negotiate()
436 irda_qos_bits_to_value(&self->qos_rx); irlap_qos_negotiate()
438 irlap_adjust_qos_settings(&self->qos_tx); irlap_qos_negotiate()
441 self->qos_tx.baud_rate.value); irlap_qos_negotiate()
443 self->qos_tx.data_size.value); irlap_qos_negotiate()
445 self->qos_tx.window_size.value); irlap_qos_negotiate()
447 self->qos_tx.additional_bofs.value); irlap_qos_negotiate()
449 self->qos_tx.max_turn_time.value); irlap_qos_negotiate()
451 self->qos_tx.min_turn_time.value); irlap_qos_negotiate()
453 self->qos_tx.link_disc_time.value); irlap_qos_negotiate()
463 int irlap_insert_qos_negotiation_params(struct irlap_cb *self, irlap_insert_qos_negotiation_params() argument
469 ret = irda_param_insert(self, PI_BAUD_RATE, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
476 ret = irda_param_insert(self, PI_MAX_TURN_TIME, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
483 ret = irda_param_insert(self, PI_DATA_SIZE, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
490 ret = irda_param_insert(self, PI_WINDOW_SIZE, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
497 ret = irda_param_insert(self, PI_ADD_BOFS, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
504 ret = irda_param_insert(self, PI_MIN_TURN_TIME, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
511 ret = irda_param_insert(self, PI_LINK_DISC, skb_tail_pointer(skb), irlap_insert_qos_negotiation_params()
530 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_baud_rate() local
532 IRDA_ASSERT(self != NULL, return -1;); irlap_param_baud_rate()
533 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_baud_rate()
536 param->pv.i = self->qos_rx.baud_rate.bits; irlap_param_baud_rate()
545 final = (__u16) param->pv.i & self->qos_rx.baud_rate.bits; irlap_param_baud_rate()
548 self->qos_tx.baud_rate.bits = final; irlap_param_baud_rate()
549 self->qos_rx.baud_rate.bits = final; irlap_param_baud_rate()
566 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_link_disconnect() local
568 IRDA_ASSERT(self != NULL, return -1;); irlap_param_link_disconnect()
569 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_link_disconnect()
572 param->pv.i = self->qos_rx.link_disc_time.bits; irlap_param_link_disconnect()
579 final = (__u8) param->pv.i & self->qos_rx.link_disc_time.bits; irlap_param_link_disconnect()
582 self->qos_tx.link_disc_time.bits = final; irlap_param_link_disconnect()
583 self->qos_rx.link_disc_time.bits = final; irlap_param_link_disconnect()
598 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_max_turn_time() local
600 IRDA_ASSERT(self != NULL, return -1;); irlap_param_max_turn_time()
601 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_max_turn_time()
604 param->pv.i = self->qos_rx.max_turn_time.bits; irlap_param_max_turn_time()
606 self->qos_tx.max_turn_time.bits = (__u8) param->pv.i; irlap_param_max_turn_time()
620 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_data_size() local
622 IRDA_ASSERT(self != NULL, return -1;); irlap_param_data_size()
623 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_data_size()
626 param->pv.i = self->qos_rx.data_size.bits; irlap_param_data_size()
628 self->qos_tx.data_size.bits = (__u8) param->pv.i; irlap_param_data_size()
643 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_window_size() local
645 IRDA_ASSERT(self != NULL, return -1;); irlap_param_window_size()
646 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_window_size()
649 param->pv.i = self->qos_rx.window_size.bits; irlap_param_window_size()
651 self->qos_tx.window_size.bits = (__u8) param->pv.i; irlap_param_window_size()
664 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_additional_bofs() local
666 IRDA_ASSERT(self != NULL, return -1;); irlap_param_additional_bofs()
667 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_additional_bofs()
670 param->pv.i = self->qos_rx.additional_bofs.bits; irlap_param_additional_bofs()
672 self->qos_tx.additional_bofs.bits = (__u8) param->pv.i; irlap_param_additional_bofs()
686 struct irlap_cb *self = (struct irlap_cb *) instance; irlap_param_min_turn_time() local
688 IRDA_ASSERT(self != NULL, return -1;); irlap_param_min_turn_time()
689 IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;); irlap_param_min_turn_time()
692 param->pv.i = self->qos_rx.min_turn_time.bits; irlap_param_min_turn_time()
694 self->qos_tx.min_turn_time.bits = (__u8) param->pv.i; irlap_param_min_turn_time()
|
| H A D | parameters.c | 38 static int irda_extract_integer(void *self, __u8 *buf, int len, __u8 pi,
40 static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi,
42 static int irda_extract_octseq(void *self, __u8 *buf, int len, __u8 pi,
44 static int irda_extract_no_value(void *self, __u8 *buf, int len, __u8 pi,
47 static int irda_insert_integer(void *self, __u8 *buf, int len, __u8 pi,
49 static int irda_insert_no_value(void *self, __u8 *buf, int len, __u8 pi,
76 * Function irda_insert_no_value (self, buf, len, pi, type, func)
78 static int irda_insert_no_value(void *self, __u8 *buf, int len, __u8 pi, irda_insert_no_value() argument
88 ret = (*func)(self, &p, PV_GET); irda_insert_no_value()
100 * Function irda_extract_no_value (self, buf, len, type, func)
105 static int irda_extract_no_value(void *self, __u8 *buf, int len, __u8 pi, irda_extract_no_value() argument
115 ret = (*func)(self, &p, PV_PUT); irda_extract_no_value()
124 * Function irda_insert_integer (self, buf, len, pi, type, func)
126 static int irda_insert_integer(void *self, __u8 *buf, int len, __u8 pi, irda_insert_integer() argument
138 err = (*func)(self, &p, PV_GET); irda_insert_integer()
197 * Function irda_extract integer (self, buf, len, pi, type, func)
202 static int irda_extract_integer(void *self, __u8 *buf, int len, __u8 pi, irda_extract_integer() argument
276 err = (*func)(self, &p, PV_PUT); irda_extract_integer()
284 * Function irda_extract_string (self, buf, len, type, func)
286 static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi, irda_extract_string() argument
321 err = (*func)(self, &p, PV_PUT); irda_extract_string()
329 * Function irda_extract_octseq (self, buf, len, type, func)
331 static int irda_extract_octseq(void *self, __u8 *buf, int len, __u8 pi, irda_extract_octseq() argument
444 * Function irda_param_insert (self, pi, buf, len, info)
449 int irda_param_insert(void *self, __u8 pi, __u8 *buf, int len, irda_param_insert() argument
491 ret = (*pv_insert_table[type & PV_MASK])(self, buf+n, len, pi, type, irda_param_insert()
498 * Function irda_param_extract (self, buf, len, info)
504 static int irda_param_extract(void *self, __u8 *buf, int len, irda_param_extract() argument
549 ret = (*pv_extract_table[type & PV_MASK])(self, buf+n, len, buf[n], irda_param_extract()
555 * Function irda_param_extract_all (self, buf, len, info)
561 int irda_param_extract_all(void *self, __u8 *buf, int len, irda_param_extract_all() argument
575 ret = irda_param_extract(self, buf+n, len, info); irda_param_extract_all()
|
| H A D | irda_device.c | 99 * Function irda_device_set_media_busy (self, status)
106 struct irlap_cb *self; irda_device_set_media_busy() local
110 self = (struct irlap_cb *) dev->atalk_ptr; irda_device_set_media_busy()
119 if (!self || self->magic != LAP_MAGIC) irda_device_set_media_busy()
123 self->media_busy = TRUE; irda_device_set_media_busy()
125 irlap_start_mbusy_timer(self, SMALLBUSY_TIMEOUT); irda_device_set_media_busy()
127 irlap_start_mbusy_timer(self, MEDIABUSY_TIMEOUT); irda_device_set_media_busy()
130 self->media_busy = FALSE; irda_device_set_media_busy()
131 irlap_stop_mbusy_timer(self); irda_device_set_media_busy()
|
| /linux-4.1.27/net/irda/irlan/ |
| H A D | irlan_client_event.c | 39 static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
41 static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
43 static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
45 static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
47 static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
49 static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
51 static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
53 static int irlan_client_state_arb (struct irlan_cb *self, IRLAN_EVENT event,
55 static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
57 static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
59 static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
77 void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event, irlan_do_client_event() argument
80 IRDA_ASSERT(self != NULL, return;); irlan_do_client_event()
81 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_do_client_event()
83 (*state[ self->client.state]) (self, event, skb); irlan_do_client_event()
92 static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_idle() argument
95 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_idle()
96 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_client_state_idle()
100 if (self->client.iriap) { irlan_client_state_idle()
106 self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, irlan_client_state_idle()
109 irlan_next_client_state(self, IRLAN_QUERY); irlan_client_state_idle()
110 iriap_getvaluebyclass_request(self->client.iriap, irlan_client_state_idle()
111 self->saddr, self->daddr, irlan_client_state_idle()
134 static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_query() argument
137 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_query()
138 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_client_state_query()
142 IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;); irlan_client_state_query()
144 self->client.open_retries = 0; irlan_client_state_query()
146 irttp_connect_request(self->client.tsap_ctrl, irlan_client_state_query()
147 self->dtsap_sel_ctrl, irlan_client_state_query()
148 self->saddr, self->daddr, NULL, irlan_client_state_query()
150 irlan_next_client_state(self, IRLAN_CONN); irlan_client_state_query()
154 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_query()
157 if ((self->provider.access_type == ACCESS_PEER) && irlan_client_state_query()
158 (self->provider.state != IRLAN_IDLE)) irlan_client_state_query()
159 irlan_client_wakeup(self, self->saddr, self->daddr); irlan_client_state_query()
163 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_query()
185 static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_conn() argument
188 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_conn()
193 irlan_get_provider_info(self); irlan_client_state_conn()
194 irlan_next_client_state(self, IRLAN_INFO); irlan_client_state_conn()
198 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_conn()
214 * Function irlan_client_state_info (self, event, skb, info)
218 static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_info() argument
221 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_info()
227 irlan_client_parse_response(self, skb); irlan_client_state_info()
229 irlan_next_client_state(self, IRLAN_MEDIA); irlan_client_state_info()
231 irlan_get_media_char(self); irlan_client_state_info()
236 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_info()
252 * Function irlan_client_state_media (self, event, skb, info)
258 static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_media() argument
261 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_media()
265 irlan_client_parse_response(self, skb); irlan_client_state_media()
266 irlan_open_data_channel(self); irlan_client_state_media()
267 irlan_next_client_state(self, IRLAN_OPEN); irlan_client_state_media()
271 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_media()
287 * Function irlan_client_state_open (self, event, skb, info)
293 static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_open() argument
298 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_open()
302 irlan_client_parse_response(self, skb); irlan_client_state_open()
308 IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;); irlan_client_state_open()
311 switch (self->client.access_type) { irlan_client_state_open()
313 if (self->provider.state == IRLAN_OPEN) { irlan_client_state_open()
315 irlan_next_client_state(self, IRLAN_ARB); irlan_client_state_open()
316 irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, irlan_client_state_open()
320 irlan_next_client_state(self, IRLAN_WAIT); irlan_client_state_open()
327 irttp_connect_request(self->tsap_data, irlan_client_state_open()
328 self->dtsap_sel_data, irlan_client_state_open()
329 self->saddr, self->daddr, &qos, irlan_client_state_open()
332 irlan_next_client_state(self, IRLAN_DATA); irlan_client_state_open()
341 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_open()
358 * Function irlan_client_state_wait (self, event, skb, info)
364 static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_wait() argument
367 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_wait()
371 irlan_next_client_state(self, IRLAN_ARB); irlan_client_state_wait()
372 irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, NULL); irlan_client_state_wait()
376 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_wait()
391 static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_arb() argument
396 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_arb()
400 if (self->client.recv_arb_val == self->provider.send_arb_val) { irlan_client_state_arb()
401 irlan_next_client_state(self, IRLAN_CLOSE); irlan_client_state_arb()
402 irlan_close_data_channel(self); irlan_client_state_arb()
403 } else if (self->client.recv_arb_val < irlan_client_state_arb()
404 self->provider.send_arb_val) irlan_client_state_arb()
408 irlan_next_client_state(self, IRLAN_DATA); irlan_client_state_arb()
409 irttp_connect_request(self->tsap_data, irlan_client_state_arb()
410 self->dtsap_sel_data, irlan_client_state_arb()
411 self->saddr, self->daddr, &qos, irlan_client_state_arb()
413 } else if (self->client.recv_arb_val > irlan_client_state_arb()
414 self->provider.send_arb_val) irlan_client_state_arb()
420 irlan_next_client_state(self, IRLAN_DATA); irlan_client_state_arb()
424 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_arb()
440 * Function irlan_client_state_data (self, event, skb, info)
446 static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_data() argument
449 IRDA_ASSERT(self != NULL, return -1;); irlan_client_state_data()
450 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_client_state_data()
454 irlan_client_parse_response(self, skb); irlan_client_state_data()
458 irlan_next_client_state(self, IRLAN_IDLE); irlan_client_state_data()
471 * Function irlan_client_state_close (self, event, skb, info)
476 static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_close() argument
486 * Function irlan_client_state_sync (self, event, skb, info)
491 static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event, irlan_client_state_sync() argument
|
| H A D | irlan_filter.c | 33 * Function irlan_filter_request (self, skb)
38 void irlan_filter_request(struct irlan_cb *self, struct sk_buff *skb) irlan_filter_request() argument
40 IRDA_ASSERT(self != NULL, return;); irlan_filter_request()
41 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_filter_request()
43 if ((self->provider.filter_type == IRLAN_DIRECTED) && irlan_filter_request()
44 (self->provider.filter_operation == DYNAMIC)) irlan_filter_request()
47 self->provider.mac_address[0] = 0x40; irlan_filter_request()
48 self->provider.mac_address[1] = 0x00; irlan_filter_request()
49 self->provider.mac_address[2] = 0x00; irlan_filter_request()
50 self->provider.mac_address[3] = 0x00; irlan_filter_request()
53 if (self->provider.access_type == ACCESS_PEER) { irlan_filter_request()
54 self->provider.mac_address[4] = irlan_filter_request()
55 self->provider.send_arb_val & 0xff; irlan_filter_request()
56 self->provider.mac_address[5] = irlan_filter_request()
57 (self->provider.send_arb_val >> 8) & 0xff; irlan_filter_request()
60 get_random_bytes(self->provider.mac_address+4, 1); irlan_filter_request()
61 get_random_bytes(self->provider.mac_address+5, 1); irlan_filter_request()
69 self->provider.mac_address, 6); irlan_filter_request()
73 if ((self->provider.filter_type == IRLAN_DIRECTED) && irlan_filter_request()
74 (self->provider.filter_mode == FILTER)) irlan_filter_request()
81 if ((self->provider.filter_type == IRLAN_DIRECTED) && irlan_filter_request()
82 (self->provider.filter_mode == NONE)) irlan_filter_request()
90 if ((self->provider.filter_type == IRLAN_BROADCAST) && irlan_filter_request()
91 (self->provider.filter_mode == FILTER)) irlan_filter_request()
98 if ((self->provider.filter_type == IRLAN_BROADCAST) && irlan_filter_request()
99 (self->provider.filter_mode == NONE)) irlan_filter_request()
106 if ((self->provider.filter_type == IRLAN_MULTICAST) && irlan_filter_request()
107 (self->provider.filter_mode == FILTER)) irlan_filter_request()
114 if ((self->provider.filter_type == IRLAN_MULTICAST) && irlan_filter_request()
115 (self->provider.filter_mode == NONE)) irlan_filter_request()
122 if ((self->provider.filter_type == IRLAN_MULTICAST) && irlan_filter_request()
123 (self->provider.filter_operation == GET)) irlan_filter_request()
139 * Function check_request_param (self, param, value)
144 void irlan_check_command_param(struct irlan_cb *self, char *param, char *value) irlan_check_command_param() argument
146 IRDA_ASSERT(self != NULL, return;); irlan_check_command_param()
147 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_check_command_param()
155 self->use_udata = TRUE; irlan_check_command_param()
164 self->provider.filter_type = IRLAN_DIRECTED; irlan_check_command_param()
168 self->provider.filter_type = IRLAN_MULTICAST; irlan_check_command_param()
172 self->provider.filter_type = IRLAN_BROADCAST; irlan_check_command_param()
181 self->provider.filter_mode = ALL; irlan_check_command_param()
185 self->provider.filter_mode = FILTER; irlan_check_command_param()
189 self->provider.filter_mode = FILTER; irlan_check_command_param()
198 self->provider.filter_operation = DYNAMIC; irlan_check_command_param()
202 self->provider.filter_operation = GET; irlan_check_command_param()
|
| H A D | irlan_provider_event.c | 33 static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
35 static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
37 static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
39 static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
42 static int (*state[])(struct irlan_cb *self, IRLAN_EVENT event,
58 void irlan_do_provider_event(struct irlan_cb *self, IRLAN_EVENT event, irlan_do_provider_event() argument
61 IRDA_ASSERT(*state[ self->provider.state] != NULL, return;); irlan_do_provider_event()
63 (*state[self->provider.state]) (self, event, skb); irlan_do_provider_event()
72 static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event, irlan_provider_state_idle() argument
75 IRDA_ASSERT(self != NULL, return -1;); irlan_provider_state_idle()
79 irlan_provider_connect_response( self, self->provider.tsap_ctrl); irlan_provider_state_idle()
80 irlan_next_provider_state( self, IRLAN_INFO); irlan_provider_state_idle()
93 * Function irlan_provider_state_info (self, event, skb, info)
97 static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event, irlan_provider_state_info() argument
102 IRDA_ASSERT(self != NULL, return -1;); irlan_provider_state_info()
107 if (self->provider.access_type == ACCESS_PEER) { irlan_provider_state_info()
108 self->media = MEDIA_802_3; irlan_provider_state_info()
111 if (self->client.state == IRLAN_IDLE) { irlan_provider_state_info()
117 irlan_provider_send_reply(self, CMD_GET_PROVIDER_INFO, irlan_provider_state_info()
122 irlan_provider_send_reply(self, CMD_GET_MEDIA_CHAR, irlan_provider_state_info()
127 ret = irlan_parse_open_data_cmd(self, skb); irlan_provider_state_info()
128 if (self->provider.access_type == ACCESS_PEER) { irlan_provider_state_info()
130 self->provider.send_arb_val = (jiffies & 0xffff); irlan_provider_state_info()
132 irlan_provider_send_reply(self, CMD_OPEN_DATA_CHANNEL, ret); irlan_provider_state_info()
135 irlan_next_provider_state(self, IRLAN_OPEN); irlan_provider_state_info()
138 irlan_do_client_event(self, IRLAN_PROVIDER_SIGNAL, NULL); irlan_provider_state_info()
143 irlan_next_provider_state(self, IRLAN_IDLE); irlan_provider_state_info()
156 * Function irlan_provider_state_open (self, event, skb, info)
162 static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event, irlan_provider_state_open() argument
165 IRDA_ASSERT(self != NULL, return -1;); irlan_provider_state_open()
169 irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb); irlan_provider_state_open()
170 irlan_provider_send_reply(self, CMD_FILTER_OPERATION, irlan_provider_state_open()
175 irlan_next_provider_state(self, IRLAN_DATA); irlan_provider_state_open()
176 irlan_provider_connect_response(self, self->tsap_data); irlan_provider_state_open()
180 irlan_next_provider_state(self, IRLAN_IDLE); irlan_provider_state_open()
193 * Function irlan_provider_state_data (self, event, skb, info)
199 static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event, irlan_provider_state_data() argument
202 IRDA_ASSERT(self != NULL, return -1;); irlan_provider_state_data()
203 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_provider_state_data()
207 irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb); irlan_provider_state_data()
208 irlan_provider_send_reply(self, CMD_FILTER_OPERATION, irlan_provider_state_data()
213 irlan_next_provider_state(self, IRLAN_IDLE); irlan_provider_state_data()
|
| H A D | irlan_client.c | 67 static void irlan_check_response_param(struct irlan_cb *self, char *param,
69 static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);
73 struct irlan_cb *self = (struct irlan_cb *) data; irlan_client_kick_timer_expired() local
75 IRDA_ASSERT(self != NULL, return;); irlan_client_kick_timer_expired()
76 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_kick_timer_expired()
83 if ((self->provider.access_type == ACCESS_PEER) && irlan_client_kick_timer_expired()
84 (self->client.state == IRLAN_IDLE) && irlan_client_kick_timer_expired()
85 (self->provider.state != IRLAN_IDLE)) { irlan_client_kick_timer_expired()
86 irlan_client_wakeup(self, self->saddr, self->daddr); irlan_client_kick_timer_expired()
90 static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout) irlan_client_start_kick_timer() argument
92 irda_start_timer(&self->client.kick_timer, timeout, (void *) self, irlan_client_start_kick_timer()
97 * Function irlan_client_wakeup (self, saddr, daddr)
102 void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr) irlan_client_wakeup() argument
104 IRDA_ASSERT(self != NULL, return;); irlan_client_wakeup()
105 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_wakeup()
111 if ((self->client.state != IRLAN_IDLE) || irlan_client_wakeup()
112 (self->provider.access_type == ACCESS_DIRECT)) irlan_client_wakeup()
119 self->saddr = saddr; irlan_client_wakeup()
120 self->daddr = daddr; irlan_client_wakeup()
122 if (self->disconnect_reason == LM_USER_REQUEST) { irlan_client_wakeup()
128 irlan_client_open_ctrl_tsap(self); irlan_client_wakeup()
129 irlan_open_data_tsap(self); irlan_client_wakeup()
131 irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL); irlan_client_wakeup()
134 irlan_client_start_kick_timer(self, 2*HZ); irlan_client_wakeup()
147 struct irlan_cb *self; irlan_client_discovery_indication() local
166 self = irlan_get_any(); irlan_client_discovery_indication()
167 if (self) { irlan_client_discovery_indication()
168 IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;); irlan_client_discovery_indication()
173 irlan_client_wakeup(self, saddr, daddr); irlan_client_discovery_indication()
188 struct irlan_cb *self; irlan_client_ctrl_data_indication() local
190 self = instance; irlan_client_ctrl_data_indication()
192 IRDA_ASSERT(self != NULL, return -1;); irlan_client_ctrl_data_indication()
193 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_client_ctrl_data_indication()
196 irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb); irlan_client_ctrl_data_indication()
200 self->client.tx_busy = FALSE; irlan_client_ctrl_data_indication()
203 irlan_run_ctrl_tx_queue(self); irlan_client_ctrl_data_indication()
212 struct irlan_cb *self; irlan_client_ctrl_disconnect_indication() local
218 self = instance; irlan_client_ctrl_disconnect_indication()
221 IRDA_ASSERT(self != NULL, return;); irlan_client_ctrl_disconnect_indication()
222 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_ctrl_disconnect_indication()
226 IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;); irlan_client_ctrl_disconnect_indication()
229 while ((skb = skb_dequeue(&self->client.txq)) != NULL) { irlan_client_ctrl_disconnect_indication()
232 self->client.tx_busy = FALSE; irlan_client_ctrl_disconnect_indication()
234 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL); irlan_client_ctrl_disconnect_indication()
238 * Function irlan_client_open_tsaps (self)
243 static void irlan_client_open_ctrl_tsap(struct irlan_cb *self) irlan_client_open_ctrl_tsap() argument
248 IRDA_ASSERT(self != NULL, return;); irlan_client_open_ctrl_tsap()
249 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_open_ctrl_tsap()
252 if (self->client.tsap_ctrl) irlan_client_open_ctrl_tsap()
261 notify.instance = self; irlan_client_open_ctrl_tsap()
269 self->client.tsap_ctrl = tsap; irlan_client_open_ctrl_tsap()
284 struct irlan_cb *self; irlan_client_ctrl_connect_confirm() local
286 self = instance; irlan_client_ctrl_connect_confirm()
288 IRDA_ASSERT(self != NULL, return;); irlan_client_ctrl_connect_confirm()
289 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_ctrl_connect_confirm()
291 self->client.max_sdu_size = max_sdu_size; irlan_client_ctrl_connect_confirm()
292 self->client.max_header_size = max_header_size; irlan_client_ctrl_connect_confirm()
296 irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL); irlan_client_ctrl_connect_confirm()
345 * Function irlan_client_parse_response (self, skb)
350 void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb) irlan_client_parse_response() argument
365 IRDA_ASSERT(self != NULL, return;); irlan_client_parse_response()
366 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_parse_response()
406 irlan_check_response_param(self, name, value, val_len); irlan_client_parse_response()
414 * Function irlan_check_response_param (self, param, value, val_len)
419 static void irlan_check_response_param(struct irlan_cb *self, char *param, irlan_check_response_param() argument
428 IRDA_ASSERT(self != NULL, return;); irlan_check_response_param()
429 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_check_response_param()
434 self->media = MEDIA_802_3; irlan_check_response_param()
436 self->media = MEDIA_802_5; irlan_check_response_param()
441 self->client.filter_type |= IRLAN_DIRECTED; irlan_check_response_param()
443 self->client.filter_type |= IRLAN_FUNCTIONAL; irlan_check_response_param()
445 self->client.filter_type |= IRLAN_GROUP; irlan_check_response_param()
447 self->client.filter_type |= IRLAN_MAC_FRAME; irlan_check_response_param()
449 self->client.filter_type |= IRLAN_MULTICAST; irlan_check_response_param()
451 self->client.filter_type |= IRLAN_BROADCAST; irlan_check_response_param()
453 self->client.filter_type |= IRLAN_IPX_SOCKET; irlan_check_response_param()
458 self->client.access_type = ACCESS_DIRECT; irlan_check_response_param()
460 self->client.access_type = ACCESS_PEER; irlan_check_response_param()
462 self->client.access_type = ACCESS_HOSTED; irlan_check_response_param()
472 self->version[0] = value[0]; irlan_check_response_param()
473 self->version[1] = value[1]; irlan_check_response_param()
478 self->dtsap_sel_data = value[0]; irlan_check_response_param()
479 pr_debug("Data TSAP = %02x\n", self->dtsap_sel_data); irlan_check_response_param()
485 self->client.recv_arb_val = tmp_cpu; irlan_check_response_param()
487 self->client.recv_arb_val); irlan_check_response_param()
492 self->client.max_frame = tmp_cpu; irlan_check_response_param()
494 self->client.max_frame); irlan_check_response_param()
502 memcpy(self->client.reconnect_key, value, val_len); irlan_check_response_param()
503 self->client.key_len = val_len; irlan_check_response_param()
511 self->dev->dev_addr[i] = bytes[i]; irlan_check_response_param()
524 struct irlan_cb *self; irlan_client_get_value_confirm() local
528 self = priv; irlan_client_get_value_confirm()
529 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_client_get_value_confirm()
532 iriap_close(self->client.iriap); irlan_client_get_value_confirm()
533 self->client.iriap = NULL; irlan_client_get_value_confirm()
538 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, irlan_client_get_value_confirm()
545 self->dtsap_sel_ctrl = value->t.integer; irlan_client_get_value_confirm()
548 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL, irlan_client_get_value_confirm()
558 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL); irlan_client_get_value_confirm()
|
| H A D | irlan_common.c | 102 static void __irlan_close(struct irlan_cb *self);
106 static void irlan_open_unicast_addr(struct irlan_cb *self);
107 static void irlan_get_unicast_addr(struct irlan_cb *self);
108 void irlan_close_tsaps(struct irlan_cb *self);
171 struct irlan_cb *self, *next; irlan_cleanup() local
182 list_for_each_entry_safe(self, next, &irlans, dev_list) { irlan_cleanup()
183 __irlan_close(self); irlan_cleanup()
197 struct irlan_cb *self; irlan_open() local
204 self = netdev_priv(dev); irlan_open()
205 self->dev = dev; irlan_open()
210 self->magic = IRLAN_MAGIC; irlan_open()
211 self->saddr = saddr; irlan_open()
212 self->daddr = daddr; irlan_open()
215 self->provider.access_type = access; irlan_open()
229 self->media = MEDIA_802_3; irlan_open()
230 self->disconnect_reason = LM_USER_REQUEST; irlan_open()
231 init_timer(&self->watchdog_timer); irlan_open()
232 init_timer(&self->client.kick_timer); irlan_open()
233 init_waitqueue_head(&self->open_wait); irlan_open()
235 skb_queue_head_init(&self->client.txq); irlan_open()
237 irlan_next_client_state(self, IRLAN_IDLE); irlan_open()
238 irlan_next_provider_state(self, IRLAN_IDLE); irlan_open()
243 self = NULL; irlan_open()
247 list_add_rcu(&self->dev_list, &irlans); irlan_open()
251 return self; irlan_open()
254 * Function __irlan_close (self)
258 * remove self from irlans list first.
260 static void __irlan_close(struct irlan_cb *self) __irlan_close() argument
263 IRDA_ASSERT(self != NULL, return;); __irlan_close()
264 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); __irlan_close()
266 del_timer_sync(&self->watchdog_timer); __irlan_close()
267 del_timer_sync(&self->client.kick_timer); __irlan_close()
270 irlan_close_tsaps(self); __irlan_close()
272 if (self->client.iriap) __irlan_close()
273 iriap_close(self->client.iriap); __irlan_close()
276 skb_queue_purge(&self->client.txq); __irlan_close()
278 /* Unregister and free self via destructor */ __irlan_close()
279 unregister_netdevice(self->dev); __irlan_close()
285 struct irlan_cb *self; irlan_get_any() local
287 list_for_each_entry_rcu(self, &irlans, dev_list) { irlan_get_any()
288 return self; irlan_get_any()
305 struct irlan_cb *self; irlan_connect_indication() local
308 self = instance; irlan_connect_indication()
311 IRDA_ASSERT(self != NULL, return;); irlan_connect_indication()
312 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_connect_indication()
313 IRDA_ASSERT(tsap == self->tsap_data,return;); irlan_connect_indication()
315 self->max_sdu_size = max_sdu_size; irlan_connect_indication()
316 self->max_header_size = max_header_size; irlan_connect_indication()
320 del_timer(&self->watchdog_timer); irlan_connect_indication()
329 irlan_do_provider_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL); irlan_connect_indication()
330 irlan_do_client_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL); irlan_connect_indication()
332 if (self->provider.access_type == ACCESS_PEER) { irlan_connect_indication()
337 irlan_get_unicast_addr(self); irlan_connect_indication()
338 irlan_open_unicast_addr(self); irlan_connect_indication()
341 netif_start_queue(self->dev); /* Clear reason */ irlan_connect_indication()
350 struct irlan_cb *self; irlan_connect_confirm() local
352 self = instance; irlan_connect_confirm()
354 IRDA_ASSERT(self != NULL, return;); irlan_connect_confirm()
355 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_connect_confirm()
357 self->max_sdu_size = max_sdu_size; irlan_connect_confirm()
358 self->max_header_size = max_header_size; irlan_connect_confirm()
363 del_timer(&self->watchdog_timer); irlan_connect_confirm()
369 irlan_get_unicast_addr(self); irlan_connect_confirm()
370 irlan_open_unicast_addr(self); irlan_connect_confirm()
373 irlan_set_broadcast_filter(self, TRUE); irlan_connect_confirm()
374 irlan_set_multicast_filter(self, TRUE); irlan_connect_confirm()
377 netif_start_queue(self->dev); irlan_connect_confirm()
378 self->disconnect_reason = 0; /* Clear reason */ irlan_connect_confirm()
379 wake_up_interruptible(&self->open_wait); irlan_connect_confirm()
392 struct irlan_cb *self; irlan_disconnect_indication() local
397 self = instance; irlan_disconnect_indication()
400 IRDA_ASSERT(self != NULL, return;); irlan_disconnect_indication()
401 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_disconnect_indication()
405 IRDA_ASSERT(tsap == self->tsap_data, return;); irlan_disconnect_indication()
410 self->disconnect_reason = reason; irlan_disconnect_indication()
441 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL); irlan_disconnect_indication()
442 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL); irlan_disconnect_indication()
444 wake_up_interruptible(&self->open_wait); irlan_disconnect_indication()
447 void irlan_open_data_tsap(struct irlan_cb *self) irlan_open_data_tsap() argument
452 IRDA_ASSERT(self != NULL, return;); irlan_open_data_tsap()
453 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_open_data_tsap()
456 if (self->tsap_data) irlan_open_data_tsap()
467 notify.instance = self; irlan_open_data_tsap()
475 self->tsap_data = tsap; irlan_open_data_tsap()
481 self->stsap_sel_data = self->tsap_data->stsap_sel; irlan_open_data_tsap()
484 void irlan_close_tsaps(struct irlan_cb *self) irlan_close_tsaps() argument
486 IRDA_ASSERT(self != NULL, return;); irlan_close_tsaps()
487 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_close_tsaps()
490 if (self->tsap_data) { irlan_close_tsaps()
491 irttp_disconnect_request(self->tsap_data, NULL, P_NORMAL); irlan_close_tsaps()
492 irttp_close_tsap(self->tsap_data); irlan_close_tsaps()
493 self->tsap_data = NULL; irlan_close_tsaps()
495 if (self->client.tsap_ctrl) { irlan_close_tsaps()
496 irttp_disconnect_request(self->client.tsap_ctrl, NULL, irlan_close_tsaps()
498 irttp_close_tsap(self->client.tsap_ctrl); irlan_close_tsaps()
499 self->client.tsap_ctrl = NULL; irlan_close_tsaps()
501 if (self->provider.tsap_ctrl) { irlan_close_tsaps()
502 irttp_disconnect_request(self->provider.tsap_ctrl, NULL, irlan_close_tsaps()
504 irttp_close_tsap(self->provider.tsap_ctrl); irlan_close_tsaps()
505 self->provider.tsap_ctrl = NULL; irlan_close_tsaps()
507 self->disconnect_reason = LM_USER_REQUEST; irlan_close_tsaps()
511 * Function irlan_ias_register (self, tsap_sel)
516 void irlan_ias_register(struct irlan_cb *self, __u8 tsap_sel) irlan_ias_register() argument
521 IRDA_ASSERT(self != NULL, return;); irlan_ias_register()
522 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_ias_register()
551 if (self->provider.access_type == ACCESS_PEER) irlan_ias_register()
565 * Function irlan_run_ctrl_tx_queue (self)
570 int irlan_run_ctrl_tx_queue(struct irlan_cb *self) irlan_run_ctrl_tx_queue() argument
574 if (irda_lock(&self->client.tx_busy) == FALSE) irlan_run_ctrl_tx_queue()
577 skb = skb_dequeue(&self->client.txq); irlan_run_ctrl_tx_queue()
579 self->client.tx_busy = FALSE; irlan_run_ctrl_tx_queue()
584 if ((self->client.tsap_ctrl == NULL) || irlan_run_ctrl_tx_queue()
585 (self->client.state == IRLAN_IDLE)) irlan_run_ctrl_tx_queue()
587 self->client.tx_busy = FALSE; irlan_run_ctrl_tx_queue()
593 return irttp_data_request(self->client.tsap_ctrl, skb); irlan_run_ctrl_tx_queue()
597 * Function irlan_ctrl_data_request (self, skb)
602 static void irlan_ctrl_data_request(struct irlan_cb *self, struct sk_buff *skb) irlan_ctrl_data_request() argument
605 skb_queue_tail(&self->client.txq, skb); irlan_ctrl_data_request()
608 irlan_run_ctrl_tx_queue(self); irlan_ctrl_data_request()
612 * Function irlan_get_provider_info (self)
617 void irlan_get_provider_info(struct irlan_cb *self) irlan_get_provider_info() argument
622 IRDA_ASSERT(self != NULL, return;); irlan_get_provider_info()
623 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_get_provider_info()
631 skb_reserve(skb, self->client.max_header_size); irlan_get_provider_info()
639 irlan_ctrl_data_request(self, skb); irlan_get_provider_info()
643 * Function irlan_open_data_channel (self)
648 void irlan_open_data_channel(struct irlan_cb *self) irlan_open_data_channel() argument
653 IRDA_ASSERT(self != NULL, return;); irlan_open_data_channel()
654 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_open_data_channel()
663 skb_reserve(skb, self->client.max_header_size); irlan_open_data_channel()
676 /* self->use_udata = TRUE; */ irlan_open_data_channel()
678 irlan_ctrl_data_request(self, skb); irlan_open_data_channel()
681 void irlan_close_data_channel(struct irlan_cb *self) irlan_close_data_channel() argument
686 IRDA_ASSERT(self != NULL, return;); irlan_close_data_channel()
687 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_close_data_channel()
690 if (self->client.tsap_ctrl == NULL) irlan_close_data_channel()
699 skb_reserve(skb, self->client.max_header_size); irlan_close_data_channel()
708 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); irlan_close_data_channel()
710 irlan_ctrl_data_request(self, skb); irlan_close_data_channel()
714 * Function irlan_open_unicast_addr (self)
720 static void irlan_open_unicast_addr(struct irlan_cb *self) irlan_open_unicast_addr() argument
725 IRDA_ASSERT(self != NULL, return;); irlan_open_unicast_addr()
726 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_open_unicast_addr()
737 skb_reserve(skb, self->max_header_size); irlan_open_unicast_addr()
744 irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data); irlan_open_unicast_addr()
748 irlan_ctrl_data_request(self, skb); irlan_open_unicast_addr()
752 * Function irlan_set_broadcast_filter (self, status)
760 void irlan_set_broadcast_filter(struct irlan_cb *self, int status) irlan_set_broadcast_filter() argument
765 IRDA_ASSERT(self != NULL, return;); irlan_set_broadcast_filter()
766 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_set_broadcast_filter()
778 skb_reserve(skb, self->client.max_header_size); irlan_set_broadcast_filter()
785 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); irlan_set_broadcast_filter()
792 irlan_ctrl_data_request(self, skb); irlan_set_broadcast_filter()
796 * Function irlan_set_multicast_filter (self, status)
802 void irlan_set_multicast_filter(struct irlan_cb *self, int status) irlan_set_multicast_filter() argument
807 IRDA_ASSERT(self != NULL, return;); irlan_set_multicast_filter()
808 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_set_multicast_filter()
820 skb_reserve(skb, self->client.max_header_size); irlan_set_multicast_filter()
827 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); irlan_set_multicast_filter()
834 irlan_ctrl_data_request(self, skb); irlan_set_multicast_filter()
838 * Function irlan_get_unicast_addr (self)
845 static void irlan_get_unicast_addr(struct irlan_cb *self) irlan_get_unicast_addr() argument
850 IRDA_ASSERT(self != NULL, return;); irlan_get_unicast_addr()
851 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_get_unicast_addr()
863 skb_reserve(skb, self->client.max_header_size); irlan_get_unicast_addr()
870 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); irlan_get_unicast_addr()
874 irlan_ctrl_data_request(self, skb); irlan_get_unicast_addr()
878 * Function irlan_get_media_char (self)
883 void irlan_get_media_char(struct irlan_cb *self) irlan_get_media_char() argument
888 IRDA_ASSERT(self != NULL, return;); irlan_get_media_char()
889 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_get_media_char()
899 skb_reserve(skb, self->client.max_header_size); irlan_get_media_char()
909 irlan_ctrl_data_request(self, skb); irlan_get_media_char()
1119 struct irlan_cb *self = list_entry(v, struct irlan_cb, dev_list); irlan_seq_show() local
1121 IRDA_ASSERT(self != NULL, return -1;); irlan_seq_show()
1122 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_seq_show()
1125 self->dev->name); irlan_seq_show()
1127 irlan_state[ self->client.state]); irlan_seq_show()
1129 irlan_state[ self->provider.state]); irlan_seq_show()
1131 self->saddr); irlan_seq_show()
1133 self->daddr); irlan_seq_show()
1135 self->version[1], self->version[0]); irlan_seq_show()
1137 irlan_access[self->client.access_type]); irlan_seq_show()
1139 irlan_media[self->media]); irlan_seq_show()
1143 irlan_print_filter(seq, self->client.filter_type); irlan_seq_show()
1145 netif_queue_stopped(self->dev) ? "TRUE" : "FALSE"); irlan_seq_show()
|
| H A D | irlan_provider.c | 70 struct irlan_cb *self; irlan_provider_data_indication() local
73 self = instance; irlan_provider_data_indication()
75 IRDA_ASSERT(self != NULL, return -1;); irlan_provider_data_indication()
76 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_provider_data_indication()
84 irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb); irlan_provider_data_indication()
89 irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb); irlan_provider_data_indication()
93 irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb); irlan_provider_data_indication()
97 irlan_do_provider_event(self, IRLAN_FILTER_CONFIG_CMD, skb); irlan_provider_data_indication()
126 struct irlan_cb *self; irlan_provider_connect_indication() local
129 self = instance; irlan_provider_connect_indication()
132 IRDA_ASSERT(self != NULL, return;); irlan_provider_connect_indication()
133 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_provider_connect_indication()
135 IRDA_ASSERT(tsap == self->provider.tsap_ctrl,return;); irlan_provider_connect_indication()
136 IRDA_ASSERT(self->provider.state == IRLAN_IDLE, return;); irlan_provider_connect_indication()
138 self->provider.max_sdu_size = max_sdu_size; irlan_provider_connect_indication()
139 self->provider.max_header_size = max_header_size; irlan_provider_connect_indication()
141 irlan_do_provider_event(self, IRLAN_CONNECT_INDICATION, NULL); irlan_provider_connect_indication()
148 if ((self->provider.access_type == ACCESS_PEER) && irlan_provider_connect_indication()
149 (self->client.state == IRLAN_IDLE)) irlan_provider_connect_indication()
151 irlan_client_wakeup(self, self->saddr, self->daddr); irlan_provider_connect_indication()
161 void irlan_provider_connect_response(struct irlan_cb *self, irlan_provider_connect_response() argument
164 IRDA_ASSERT(self != NULL, return;); irlan_provider_connect_response()
165 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_provider_connect_response()
175 struct irlan_cb *self; irlan_provider_disconnect_indication() local
180 self = instance; irlan_provider_disconnect_indication()
183 IRDA_ASSERT(self != NULL, return;); irlan_provider_disconnect_indication()
184 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_provider_disconnect_indication()
188 IRDA_ASSERT(tsap == self->provider.tsap_ctrl, return;); irlan_provider_disconnect_indication()
190 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL); irlan_provider_disconnect_indication()
194 * Function irlan_parse_open_data_cmd (self, skb)
199 int irlan_parse_open_data_cmd(struct irlan_cb *self, struct sk_buff *skb) irlan_parse_open_data_cmd() argument
203 ret = irlan_provider_parse_command(self, CMD_OPEN_DATA_CHANNEL, skb); irlan_parse_open_data_cmd()
206 irlan_open_data_tsap(self); irlan_parse_open_data_cmd()
218 int irlan_provider_parse_command(struct irlan_cb *self, int cmd, irlan_provider_parse_command() argument
234 IRDA_ASSERT(self != NULL, return -RSP_PROTOCOL_ERROR;); irlan_provider_parse_command()
235 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -RSP_PROTOCOL_ERROR;); irlan_provider_parse_command()
267 irlan_check_command_param(self, name, value); irlan_provider_parse_command()
277 * Function irlan_provider_send_reply (self, info)
282 void irlan_provider_send_reply(struct irlan_cb *self, int command, irlan_provider_send_reply() argument
287 IRDA_ASSERT(self != NULL, return;); irlan_provider_send_reply()
288 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_provider_send_reply()
302 skb_reserve(skb, self->provider.max_header_size); irlan_provider_send_reply()
309 switch (self->media) { irlan_provider_send_reply()
330 switch (self->provider.access_type) { irlan_provider_send_reply()
348 if (self->provider.send_arb_val) { irlan_provider_send_reply()
351 self->provider.send_arb_val); irlan_provider_send_reply()
354 irlan_insert_byte_param(skb, "DATA_CHAN", self->stsap_sel_data); irlan_provider_send_reply()
358 irlan_filter_request(self, skb); irlan_provider_send_reply()
365 irttp_data_request(self->provider.tsap_ctrl, skb); irlan_provider_send_reply()
374 int irlan_provider_open_ctrl_tsap(struct irlan_cb *self) irlan_provider_open_ctrl_tsap() argument
379 IRDA_ASSERT(self != NULL, return -1;); irlan_provider_open_ctrl_tsap()
380 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); irlan_provider_open_ctrl_tsap()
383 if (self->provider.tsap_ctrl) irlan_provider_open_ctrl_tsap()
393 notify.instance = self; irlan_provider_open_ctrl_tsap()
401 self->provider.tsap_ctrl = tsap; irlan_provider_open_ctrl_tsap()
404 irlan_ias_register(self, tsap->stsap_sel); irlan_provider_open_ctrl_tsap()
|
| H A D | irlan_event.c | 41 void irlan_next_client_state(struct irlan_cb *self, IRLAN_STATE state) irlan_next_client_state() argument
45 IRDA_ASSERT(self != NULL, return;); irlan_next_client_state()
46 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_next_client_state()
48 self->client.state = state; irlan_next_client_state()
51 void irlan_next_provider_state(struct irlan_cb *self, IRLAN_STATE state) irlan_next_provider_state() argument
55 IRDA_ASSERT(self != NULL, return;); irlan_next_provider_state()
56 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_next_provider_state()
58 self->provider.state = state; irlan_next_provider_state()
|
| H A D | irlan_eth.c | 111 struct irlan_cb *self = netdev_priv(dev); irlan_eth_open() local
117 self->disconnect_reason = 0; irlan_eth_open()
118 irlan_client_wakeup(self, self->saddr, self->daddr); irlan_eth_open()
122 return wait_event_interruptible(self->open_wait, irlan_eth_open()
123 !self->tsap_data->connected); irlan_eth_open()
136 struct irlan_cb *self = netdev_priv(dev); irlan_eth_close() local
141 irlan_close_data_channel(self); irlan_eth_close()
142 irlan_close_tsaps(self); irlan_eth_close()
144 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL); irlan_eth_close()
145 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL); irlan_eth_close()
148 skb_queue_purge(&self->client.txq); irlan_eth_close()
150 self->client.tx_busy = 0; irlan_eth_close()
164 struct irlan_cb *self = netdev_priv(dev); irlan_eth_xmit() local
169 if ((skb_headroom(skb) < self->max_header_size) || (skb_shared(skb))) { irlan_eth_xmit()
171 skb_realloc_headroom(skb, self->max_header_size); irlan_eth_xmit()
188 if (self->use_udata) irlan_eth_xmit()
189 ret = irttp_udata_request(self->tsap_data, skb); irlan_eth_xmit()
191 ret = irttp_data_request(self->tsap_data, skb); irlan_eth_xmit()
222 struct irlan_cb *self = instance; irlan_eth_receive() local
223 struct net_device *dev = self->dev; irlan_eth_receive()
268 struct irlan_cb *self; irlan_eth_flow_indication() local
271 self = instance; irlan_eth_flow_indication()
273 IRDA_ASSERT(self != NULL, return;); irlan_eth_flow_indication()
274 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); irlan_eth_flow_indication()
276 dev = self->dev; irlan_eth_flow_indication()
307 struct irlan_cb *self = netdev_priv(dev); irlan_eth_set_multicast_list() local
310 if (self->client.state != IRLAN_DATA) { irlan_eth_set_multicast_list()
324 irlan_set_multicast_filter(self, TRUE); irlan_eth_set_multicast_list()
330 irlan_set_multicast_filter(self, TRUE); irlan_eth_set_multicast_list()
333 irlan_set_multicast_filter(self, FALSE); irlan_eth_set_multicast_list()
337 irlan_set_broadcast_filter(self, TRUE); irlan_eth_set_multicast_list()
339 irlan_set_broadcast_filter(self, FALSE); irlan_eth_set_multicast_list()
|
| /linux-4.1.27/drivers/net/irda/ |
| H A D | donauboe.c | 244 toshoboe_dumpregs (struct toshoboe_cb *self) toshoboe_dumpregs() argument
254 self->int_tx, self->int_rx, self->int_txunder, self->int_rxover, toshoboe_dumpregs()
255 self->int_sip); toshoboe_dumpregs()
272 if (self->ring) toshoboe_dumpregs()
275 ringbase = virt_to_bus (self->ring); toshoboe_dumpregs()
279 printk (" (%d,%02x)",self->ring->rx[i].len,self->ring->rx[i].control); toshoboe_dumpregs()
283 printk (" (%d,%02x)",self->ring->tx[i].len,self->ring->tx[i].control); toshoboe_dumpregs()
291 toshoboe_disablebm (struct toshoboe_cb *self) toshoboe_disablebm() argument
294 pci_read_config_byte (self->pdev, PCI_COMMAND, &command); toshoboe_disablebm()
296 pci_write_config_byte (self->pdev, PCI_COMMAND, command); toshoboe_disablebm()
302 toshoboe_stopchip (struct toshoboe_cb *self) toshoboe_stopchip() argument
327 toshoboe_disablebm (self); toshoboe_stopchip()
332 toshoboe_start_DMA (struct toshoboe_cb *self, int opts) toshoboe_start_DMA() argument
342 toshoboe_setbaud (struct toshoboe_cb *self) toshoboe_setbaud() argument
347 pr_debug("%s(%d/%d)\n", __func__, self->speed, self->io.speed); toshoboe_setbaud()
349 switch (self->speed) toshoboe_setbaud()
366 self->speed); toshoboe_setbaud()
370 switch (self->speed) toshoboe_setbaud()
410 switch (self->speed) toshoboe_setbaud()
420 if (self->async) toshoboe_setbaud()
471 self->new_speed = 0; toshoboe_setbaud()
472 self->io.speed = self->speed; toshoboe_setbaud()
477 toshoboe_enablebm (struct toshoboe_cb *self) toshoboe_enablebm() argument
479 pci_set_master (self->pdev); toshoboe_enablebm()
484 toshoboe_initring (struct toshoboe_cb *self) toshoboe_initring() argument
490 self->ring->tx[i].len = 0; toshoboe_initring()
491 self->ring->tx[i].control = 0x00; toshoboe_initring()
492 self->ring->tx[i].address = virt_to_bus (self->tx_bufs[i]); toshoboe_initring()
497 self->ring->rx[i].len = RX_LEN; toshoboe_initring()
498 self->ring->rx[i].len = 0; toshoboe_initring()
499 self->ring->rx[i].address = virt_to_bus (self->rx_bufs[i]); toshoboe_initring()
500 self->ring->rx[i].control = OBOE_CTL_RX_HW_OWNS; toshoboe_initring()
505 toshoboe_resetptrs (struct toshoboe_cb *self) toshoboe_resetptrs() argument
512 self->rxs = inb_p (OBOE_RXSLOT) & OBOE_SLOT_MASK; toshoboe_resetptrs()
513 self->txs = inb_p (OBOE_TXSLOT) & OBOE_SLOT_MASK; toshoboe_resetptrs()
518 toshoboe_initptrs (struct toshoboe_cb *self) toshoboe_initptrs() argument
521 /* spin_lock_irqsave(self->spinlock, flags); */ toshoboe_initptrs()
525 toshoboe_resetptrs (self); toshoboe_initptrs()
531 self->txpending = 0; toshoboe_initptrs()
533 /* spin_unlock_irqrestore(self->spinlock, flags); */ toshoboe_initptrs()
540 toshoboe_startchip (struct toshoboe_cb *self) toshoboe_startchip() argument
544 toshoboe_initring (self); toshoboe_startchip()
545 toshoboe_enablebm (self); toshoboe_startchip()
573 physaddr = virt_to_bus (self->ring); toshoboe_startchip()
590 self->speed = 9600; toshoboe_startchip()
591 toshoboe_setbaud (self); toshoboe_startchip()
592 toshoboe_initptrs (self); toshoboe_startchip()
596 toshoboe_isntstuck (struct toshoboe_cb *self) toshoboe_isntstuck() argument
601 toshoboe_checkstuck (struct toshoboe_cb *self) toshoboe_checkstuck() argument
607 spin_lock_irqsave(&self->spinlock, flags); toshoboe_checkstuck()
612 toshoboe_stopchip (self); toshoboe_checkstuck()
613 toshoboe_startchip (self); toshoboe_checkstuck()
614 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_checkstuck()
620 toshoboe_makemttpacket (struct toshoboe_cb *self, void *buf, int mtt) toshoboe_makemttpacket() argument
624 xbofs = ((int) (mtt/100)) * (int) (self->speed); toshoboe_makemttpacket()
629 xbofs, mtt, self->speed); toshoboe_makemttpacket()
649 toshoboe_dumptx (struct toshoboe_cb *self) toshoboe_dumptx() argument
654 PROBE_DEBUG(" (%d,%02x)",self->ring->tx[i].len,self->ring->tx[i].control); toshoboe_dumptx()
655 PROBE_DEBUG(" [%d]\n",self->speed); toshoboe_dumptx()
659 toshoboe_dumprx (struct toshoboe_cb *self, int score) toshoboe_dumprx() argument
664 PROBE_DEBUG(" (%d,%02x)",self->ring->rx[i].len,self->ring->rx[i].control); toshoboe_dumprx()
692 struct toshoboe_cb *self = dev_id; toshoboe_probeinterrupt() local
708 self->int_tx++; toshoboe_probeinterrupt()
712 if (self->ring->tx[txp].control & OBOE_CTL_TX_HW_OWNS) toshoboe_probeinterrupt()
714 self->int_tx+=100; toshoboe_probeinterrupt()
716 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP); toshoboe_probeinterrupt()
721 self->int_rx++; toshoboe_probeinterrupt()
724 self->int_txunder++; toshoboe_probeinterrupt()
727 self->int_rxover++; toshoboe_probeinterrupt()
730 self->int_sip++; toshoboe_probeinterrupt()
773 toshoboe_probefail (struct toshoboe_cb *self, char *msg) toshoboe_probefail() argument
775 printk (KERN_ERR DRIVER_NAME "probe(%d) failed %s\n",self-> speed, msg); toshoboe_probefail()
776 toshoboe_dumpregs (self); toshoboe_probefail()
777 toshoboe_stopchip (self); toshoboe_probefail()
778 free_irq (self->io.irq, (void *) self); toshoboe_probefail()
783 toshoboe_numvalidrcvs (struct toshoboe_cb *self) toshoboe_numvalidrcvs() argument
787 if ((self->ring->rx[i].control & 0xe0) == 0) toshoboe_numvalidrcvs()
794 toshoboe_numrcvs (struct toshoboe_cb *self) toshoboe_numrcvs() argument
798 if (!(self->ring->rx[i].control & OBOE_CTL_RX_HW_OWNS)) toshoboe_numrcvs()
805 toshoboe_probe (struct toshoboe_cb *self) toshoboe_probe() argument
815 if (request_irq (self->io.irq, toshoboe_probeinterrupt, toshoboe_probe()
816 self->io.irqflags, "toshoboe", (void *) self)) toshoboe_probe()
819 self->io.irq); toshoboe_probe()
828 toshoboe_stopchip (self); toshoboe_probe()
831 spin_lock_irqsave(&self->spinlock, flags); toshoboe_probe()
833 toshoboe_startchip (self); toshoboe_probe()
834 self->int_rx = self->int_tx = 0; toshoboe_probe()
835 self->speed = bauds[j]; toshoboe_probe()
836 toshoboe_setbaud (self); toshoboe_probe()
837 toshoboe_initptrs (self); toshoboe_probe()
838 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_probe()
840 self->ring->tx[self->txs].control = toshoboe_probe()
845 self->ring->tx[self->txs].len = toshoboe_probe()
846 toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir); toshoboe_probe()
847 self->txs++; toshoboe_probe()
848 self->txs %= TX_SLOTS; toshoboe_probe()
850 self->ring->tx[self->txs].control = toshoboe_probe()
853 self->ring->tx[self->txs].len = toshoboe_probe()
854 toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir); toshoboe_probe()
855 self->txs++; toshoboe_probe()
856 self->txs %= TX_SLOTS; toshoboe_probe()
858 self->ring->tx[self->txs].control = toshoboe_probe()
861 self->ring->tx[self->txs].len = toshoboe_probe()
862 toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir); toshoboe_probe()
863 self->txs++; toshoboe_probe()
864 self->txs %= TX_SLOTS; toshoboe_probe()
866 self->ring->tx[self->txs].control = toshoboe_probe()
870 self->ring->tx[self->txs].len = toshoboe_probe()
871 toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir); toshoboe_probe()
872 self->txs++; toshoboe_probe()
873 self->txs %= TX_SLOTS; toshoboe_probe()
875 toshoboe_dumptx (self); toshoboe_probe()
877 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP); toshoboe_probe()
881 while (toshoboe_numvalidrcvs (self) != n) toshoboe_probe()
884 return toshoboe_probefail (self, "filter test"); toshoboe_probe()
885 udelay ((9600*(TT_LEN+16))/self->speed); toshoboe_probe()
890 while ((toshoboe_numrcvs(self) != self->int_rx) || (self->int_tx != n)) toshoboe_probe()
893 return toshoboe_probefail (self, "interrupt test"); toshoboe_probe()
894 udelay ((9600*(TT_LEN+16))/self->speed); toshoboe_probe()
897 toshoboe_dumprx (self,i); toshoboe_probe()
903 toshoboe_stopchip (self); toshoboe_probe()
904 self->int_rx = self->int_tx = 0; toshoboe_probe()
906 spin_lock_irqsave(&self->spinlock, flags); toshoboe_probe()
907 toshoboe_startchip (self); toshoboe_probe()
908 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_probe()
910 self->async = 1; toshoboe_probe()
911 self->speed = 115200; toshoboe_probe()
912 toshoboe_setbaud (self); toshoboe_probe()
913 self->ring->tx[self->txs].control = toshoboe_probe()
915 self->ring->tx[self->txs].len = 4; toshoboe_probe()
917 ((unsigned char *) self->tx_bufs[self->txs])[0] = 'f'; toshoboe_probe()
918 ((unsigned char *) self->tx_bufs[self->txs])[1] = 'i'; toshoboe_probe()
919 ((unsigned char *) self->tx_bufs[self->txs])[2] = 's'; toshoboe_probe()
920 ((unsigned char *) self->tx_bufs[self->txs])[3] = 'h'; toshoboe_probe()
921 toshoboe_dumptx (self); toshoboe_probe()
922 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP); toshoboe_probe()
925 while (toshoboe_numvalidrcvs (self) != 4) toshoboe_probe()
928 return toshoboe_probefail (self, "Async test"); toshoboe_probe()
933 while ((toshoboe_numrcvs (self) != self->int_rx) || (self->int_tx != 1)) toshoboe_probe()
936 return toshoboe_probefail (self, "Async interrupt test"); toshoboe_probe()
940 toshoboe_dumprx (self,i); toshoboe_probe()
942 self->async = 0; toshoboe_probe()
943 self->speed = 9600; toshoboe_probe()
944 toshoboe_setbaud (self); toshoboe_probe()
945 toshoboe_stopchip (self); toshoboe_probe()
947 free_irq (self->io.irq, (void *) self); toshoboe_probe()
962 struct toshoboe_cb *self; toshoboe_hard_xmit() local
968 self = netdev_priv(dev); toshoboe_hard_xmit()
970 IRDA_ASSERT (self != NULL, return NETDEV_TX_OK; ); toshoboe_hard_xmit()
973 __func__, skb->len, self->txpending, INB(OBOE_ENABLEH)); toshoboe_hard_xmit()
982 if (self->new_speed) toshoboe_hard_xmit()
986 if (self->stopped) toshoboe_hard_xmit()
989 toshoboe_checkstuck (self); toshoboe_hard_xmit()
994 if ((speed != self->io.speed) && (speed != -1)) toshoboe_hard_xmit()
996 spin_lock_irqsave(&self->spinlock, flags); toshoboe_hard_xmit()
998 if (self->txpending || skb->len) toshoboe_hard_xmit()
1000 self->new_speed = speed; toshoboe_hard_xmit()
1006 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1014 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1019 self->speed = speed; toshoboe_hard_xmit()
1020 toshoboe_setbaud (self); toshoboe_hard_xmit()
1021 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1031 spin_lock_irqsave(&self->spinlock, flags); toshoboe_hard_xmit()
1033 if (self->txpending) toshoboe_hard_xmit()
1035 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1043 mtt = toshoboe_makemttpacket (self, self->tx_bufs[self->txs], mtt); toshoboe_hard_xmit()
1044 pr_debug("%s.mtt:%x(%x)%d\n", __func__, skb->len, mtt, self->txpending); toshoboe_hard_xmit()
1047 self->ring->tx[self->txs].len = mtt & 0xfff; toshoboe_hard_xmit()
1060 self->ring->tx[self->txs].control = ctl; toshoboe_hard_xmit()
1064 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP); toshoboe_hard_xmit()
1066 self->txpending++; toshoboe_hard_xmit()
1068 self->txs++; toshoboe_hard_xmit()
1069 self->txs %= TX_SLOTS; toshoboe_hard_xmit()
1076 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1083 spin_lock_irqsave(&self->spinlock, flags); toshoboe_hard_xmit()
1085 if (self->ring->tx[self->txs].control & OBOE_CTL_TX_HW_OWNS) toshoboe_hard_xmit()
1088 __func__, skb->len, self->ring->tx[self->txs].control, toshoboe_hard_xmit()
1089 self->txpending); toshoboe_hard_xmit()
1090 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX); toshoboe_hard_xmit()
1091 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1097 len = async_wrap_skb (skb, self->tx_bufs[self->txs], TX_BUF_SZ); toshoboe_hard_xmit()
1102 skb_copy_from_linear_data(skb, self->tx_bufs[self->txs], len); toshoboe_hard_xmit()
1104 self->ring->tx[self->txs].len = len & 0x0fff; toshoboe_hard_xmit()
1115 self->ring->tx[self->txs].control = ctl; toshoboe_hard_xmit()
1119 if (!self->txpending) toshoboe_hard_xmit()
1120 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX); toshoboe_hard_xmit()
1122 self->txpending++; toshoboe_hard_xmit()
1124 self->txs++; toshoboe_hard_xmit()
1125 self->txs %= TX_SLOTS; toshoboe_hard_xmit()
1127 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_hard_xmit()
1137 struct toshoboe_cb *self = dev_id; toshoboe_interrupt() local
1150 toshoboe_isntstuck (self); toshoboe_interrupt()
1158 txp = self->txpending; toshoboe_interrupt()
1159 self->txpending = 0; toshoboe_interrupt()
1163 if (self->ring->tx[i].control & OBOE_CTL_TX_HW_OWNS) toshoboe_interrupt()
1164 self->txpending++; toshoboe_interrupt()
1166 pr_debug("%s.txd(%x)%x/%x\n", __func__, irqstat, txp, self->txpending); toshoboe_interrupt()
1171 if (self->ring->tx[txp].control & OBOE_CTL_TX_HW_OWNS) toshoboe_interrupt()
1175 while (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS) toshoboe_interrupt()
1180 self->netdev->stats.tx_packets++; toshoboe_interrupt()
1181 if (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS) toshoboe_interrupt()
1182 self->ring->tx[txp].control &= ~OBOE_CTL_TX_RTCENTX; toshoboe_interrupt()
1184 self->netdev->stats.tx_packets--; toshoboe_interrupt()
1186 self->netdev->stats.tx_packets++; toshoboe_interrupt()
1188 toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX); toshoboe_interrupt()
1191 if ((!self->txpending) && (self->new_speed)) toshoboe_interrupt()
1193 self->speed = self->new_speed; toshoboe_interrupt()
1195 __func__, self->speed); toshoboe_interrupt()
1196 toshoboe_setbaud (self); toshoboe_interrupt()
1200 if (!self->new_speed) toshoboe_interrupt()
1201 netif_wake_queue(self->netdev); toshoboe_interrupt()
1206 while (!(self->ring->rx[self->rxs].control & OBOE_CTL_RX_HW_OWNS)) toshoboe_interrupt()
1208 int len = self->ring->rx[self->rxs].len; toshoboe_interrupt()
1211 , len, self->ring->rx[self->rxs].control); toshoboe_interrupt()
1214 dumpbufs(self->rx_bufs[self->rxs],len,'<'); toshoboe_interrupt()
1217 if (self->ring->rx[self->rxs].control == 0) toshoboe_interrupt()
1225 if (!toshoboe_checkfcs (self->rx_bufs[self->rxs], len)) toshoboe_interrupt()
1264 skb_copy_to_linear_data(skb, self->rx_bufs[self->rxs], toshoboe_interrupt()
1266 self->netdev->stats.rx_packets++; toshoboe_interrupt()
1267 skb->dev = self->netdev; toshoboe_interrupt()
1288 , len, self->ring->rx[self->rxs].control); toshoboe_interrupt()
1291 self->ring->rx[self->rxs].len = 0x0; toshoboe_interrupt()
1292 self->ring->rx[self->rxs].control = OBOE_CTL_RX_HW_OWNS; toshoboe_interrupt()
1294 self->rxs++; toshoboe_interrupt()
1295 self->rxs %= RX_SLOTS; toshoboe_interrupt()
1314 self->int_sip++; toshoboe_interrupt()
1316 __func__, self->int_sip, irqstat, self->txpending); toshoboe_interrupt()
1325 struct toshoboe_cb *self; toshoboe_net_open() local
1329 self = netdev_priv(dev); toshoboe_net_open()
1331 if (self->async) toshoboe_net_open()
1334 if (self->stopped) toshoboe_net_open()
1337 rc = request_irq (self->io.irq, toshoboe_interrupt, toshoboe_net_open()
1338 IRQF_SHARED, dev->name, self); toshoboe_net_open()
1342 spin_lock_irqsave(&self->spinlock, flags); toshoboe_net_open()
1343 toshoboe_startchip (self); toshoboe_net_open()
1344 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_net_open()
1353 self->irlap = irlap_open (dev, &self->qos, driver_name); toshoboe_net_open()
1355 self->irdad = 1; toshoboe_net_open()
1363 struct toshoboe_cb *self; toshoboe_net_close() local
1366 self = netdev_priv(dev); toshoboe_net_close()
1372 if (self->irlap) toshoboe_net_close()
1373 irlap_close (self->irlap); toshoboe_net_close()
1374 self->irlap = NULL; toshoboe_net_close()
1376 self->irdad = 0; toshoboe_net_close()
1378 free_irq (self->io.irq, (void *) self); toshoboe_net_close()
1380 if (!self->stopped) toshoboe_net_close()
1382 toshoboe_stopchip (self); toshoboe_net_close()
1398 struct toshoboe_cb *self; toshoboe_net_ioctl() local
1404 self = netdev_priv(dev); toshoboe_net_ioctl()
1406 IRDA_ASSERT (self != NULL, return -1; ); toshoboe_net_ioctl()
1411 spin_lock_irqsave(&self->spinlock, flags); toshoboe_net_ioctl()
1427 /* self->speed=irq->ifr_baudrate; */ toshoboe_net_ioctl()
1428 /* toshoboe_setbaud(self); */ toshoboe_net_ioctl()
1430 self->new_speed = irq->ifr_baudrate; toshoboe_net_ioctl()
1440 irda_device_set_media_busy (self->netdev, TRUE); toshoboe_net_ioctl()
1452 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_net_ioctl()
1466 MODULE_PARM_DESC(do_probe, "Enable/disable chip probing and self-test");
1473 struct toshoboe_cb *self = pci_get_drvdata(pci_dev); toshoboe_close() local
1475 IRDA_ASSERT (self != NULL, return; ); toshoboe_close()
1477 if (!self->stopped) toshoboe_close()
1479 toshoboe_stopchip (self); toshoboe_close()
1482 release_region (self->io.fir_base, self->io.fir_ext); toshoboe_close()
1486 kfree (self->tx_bufs[i]); toshoboe_close()
1487 self->tx_bufs[i] = NULL; toshoboe_close()
1492 kfree (self->rx_bufs[i]); toshoboe_close()
1493 self->rx_bufs[i] = NULL; toshoboe_close()
1496 unregister_netdev(self->netdev); toshoboe_close()
1498 kfree (self->ringbuf); toshoboe_close()
1499 self->ringbuf = NULL; toshoboe_close()
1500 self->ring = NULL; toshoboe_close()
1502 free_netdev(self->netdev); toshoboe_close()
1515 struct toshoboe_cb *self; toshoboe_open() local
1532 self = netdev_priv(dev); toshoboe_open()
1533 self->netdev = dev; toshoboe_open()
1534 self->pdev = pci_dev; toshoboe_open()
1535 self->base = pci_resource_start(pci_dev,0); toshoboe_open()
1537 self->io.fir_base = self->base; toshoboe_open()
1538 self->io.fir_ext = OBOE_IO_EXTENT; toshoboe_open()
1539 self->io.irq = pci_dev->irq; toshoboe_open()
1540 self->io.irqflags = IRQF_SHARED; toshoboe_open()
1542 self->speed = self->io.speed = 9600; toshoboe_open()
1543 self->async = 0; toshoboe_open()
1546 if (NULL==request_region (self->io.fir_base, self->io.fir_ext, driver_name)) toshoboe_open()
1549 ,self->io.fir_base); toshoboe_open()
1554 spin_lock_init(&self->spinlock); toshoboe_open()
1556 irda_init_max_qos_capabilies (&self->qos); toshoboe_open()
1557 self->qos.baud_rate.bits = 0; toshoboe_open()
1560 self->qos.baud_rate.bits |= IR_2400; toshoboe_open()
1563 self->qos.baud_rate.bits |= IR_9600; toshoboe_open()
1565 self->qos.baud_rate.bits |= IR_19200; toshoboe_open()
1567 self->qos.baud_rate.bits |= IR_115200; toshoboe_open()
1571 self->qos.baud_rate.bits |= IR_1152000; toshoboe_open()
1576 self->qos.baud_rate.bits |= (IR_4000000 << 8); toshoboe_open()
1580 self->qos.min_turn_time.bits = 0xff; toshoboe_open()
1582 irda_qos_bits_to_value (&self->qos); toshoboe_open()
1585 self->ringbuf = kmalloc(OBOE_RING_LEN << 1, GFP_KERNEL); toshoboe_open()
1586 if (!self->ringbuf) toshoboe_open()
1600 addr = (__u32) self->ringbuf; toshoboe_open()
1603 self->ring = (struct OboeRing *) addr; toshoboe_open()
1606 memset (self->ring, 0, OBOE_RING_LEN); toshoboe_open()
1607 self->io.mem_base = (__u32) self->ring; toshoboe_open()
1612 self->tx_bufs[i] = kmalloc (TX_BUF_SZ, GFP_KERNEL); toshoboe_open()
1613 if (!self->tx_bufs[i]) toshoboe_open()
1619 self->rx_bufs[i] = kmalloc (RX_BUF_SZ, GFP_KERNEL); toshoboe_open()
1620 if (!self->rx_bufs[i]) toshoboe_open()
1633 if (!toshoboe_probe (self)) toshoboe_open()
1652 pci_set_drvdata(pci_dev,self); toshoboe_open()
1660 kfree (self->tx_bufs[i]); toshoboe_open()
1662 kfree (self->rx_bufs[i]); toshoboe_open()
1663 kfree(self->ringbuf); toshoboe_open()
1666 release_region (self->io.fir_base, self->io.fir_ext); toshoboe_open()
1677 struct toshoboe_cb *self = pci_get_drvdata(pci_dev); toshoboe_gotosleep() local
1681 if (!self || self->stopped) toshoboe_gotosleep()
1684 if ((!self->irdad) && (!self->async)) toshoboe_gotosleep()
1688 while ((i--) && (self->txpending)) toshoboe_gotosleep()
1691 spin_lock_irqsave(&self->spinlock, flags); toshoboe_gotosleep()
1693 toshoboe_stopchip (self); toshoboe_gotosleep()
1694 self->stopped = 1; toshoboe_gotosleep()
1695 self->txpending = 0; toshoboe_gotosleep()
1697 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_gotosleep()
1704 struct toshoboe_cb *self = pci_get_drvdata(pci_dev); toshoboe_wakeup() local
1707 if (!self || !self->stopped) toshoboe_wakeup()
1710 if ((!self->irdad) && (!self->async)) toshoboe_wakeup()
1713 spin_lock_irqsave(&self->spinlock, flags); toshoboe_wakeup()
1715 toshoboe_startchip (self); toshoboe_wakeup()
1716 self->stopped = 0; toshoboe_wakeup()
1718 netif_wake_queue(self->netdev); toshoboe_wakeup()
1719 spin_unlock_irqrestore(&self->spinlock, flags); toshoboe_wakeup()
|
| H A D | sh_irda.c | 135 int (*xir_fre) (struct sh_irda_self *self);
136 int (*xir_trov) (struct sh_irda_self *self);
137 int (*xir_9) (struct sh_irda_self *self);
138 int (*xir_8) (struct sh_irda_self *self);
139 int (*xir_fte) (struct sh_irda_self *self);
168 static void sh_irda_write(struct sh_irda_self *self, u32 offset, u16 data) sh_irda_write() argument
172 spin_lock_irqsave(&self->lock, flags); sh_irda_write()
173 iowrite16(data, self->membase + offset); sh_irda_write()
174 spin_unlock_irqrestore(&self->lock, flags); sh_irda_write()
177 static u16 sh_irda_read(struct sh_irda_self *self, u32 offset) sh_irda_read() argument
182 spin_lock_irqsave(&self->lock, flags); sh_irda_read()
183 ret = ioread16(self->membase + offset); sh_irda_read()
184 spin_unlock_irqrestore(&self->lock, flags); sh_irda_read()
189 static void sh_irda_update_bits(struct sh_irda_self *self, u32 offset, sh_irda_update_bits() argument
195 spin_lock_irqsave(&self->lock, flags); sh_irda_update_bits()
196 old = ioread16(self->membase + offset); sh_irda_update_bits()
199 iowrite16(data, self->membase + offset); sh_irda_update_bits()
200 spin_unlock_irqrestore(&self->lock, flags); sh_irda_update_bits()
215 static void sh_irda_rcv_ctrl(struct sh_irda_self *self, int enable) sh_irda_rcv_ctrl() argument
217 struct device *dev = &self->ndev->dev; sh_irda_rcv_ctrl()
219 sh_irda_update_bits(self, IRRCTR, RE, enable ? RE : 0); sh_irda_rcv_ctrl()
223 static int sh_irda_set_timeout(struct sh_irda_self *self, int interval) sh_irda_set_timeout() argument
225 struct device *dev = &self->ndev->dev; sh_irda_set_timeout()
227 if (SH_IRDA_SIR != self->mode) sh_irda_set_timeout()
235 sh_irda_update_bits(self, IRCFR, RTO, interval << RTO_SHIFT); sh_irda_set_timeout()
239 static int sh_irda_set_baudrate(struct sh_irda_self *self, int baudrate) sh_irda_set_baudrate() argument
241 struct device *dev = &self->ndev->dev; sh_irda_set_baudrate()
247 if (SH_IRDA_SIR != self->mode) { sh_irda_set_baudrate()
259 sh_irda_update_bits(self, SIRBCR, BRC_MASK, val); sh_irda_set_baudrate()
264 static int sh_irda_get_rcv_length(struct sh_irda_self *self) sh_irda_get_rcv_length() argument
266 return RFL_MASK & sh_irda_read(self, IRRFLR); sh_irda_get_rcv_length()
274 static int sh_irda_xir_fre(struct sh_irda_self *self) sh_irda_xir_fre() argument
276 struct device *dev = &self->ndev->dev; sh_irda_xir_fre()
281 static int sh_irda_xir_trov(struct sh_irda_self *self) sh_irda_xir_trov() argument
283 struct device *dev = &self->ndev->dev; sh_irda_xir_trov()
288 static int sh_irda_xir_9(struct sh_irda_self *self) sh_irda_xir_9() argument
290 struct device *dev = &self->ndev->dev; sh_irda_xir_9()
295 static int sh_irda_xir_8(struct sh_irda_self *self) sh_irda_xir_8() argument
297 struct device *dev = &self->ndev->dev; sh_irda_xir_8()
302 static int sh_irda_xir_fte(struct sh_irda_self *self) sh_irda_xir_fte() argument
304 struct device *dev = &self->ndev->dev; sh_irda_xir_fte()
336 static int sh_irda_sir_fre(struct sh_irda_self *self) sh_irda_sir_fre() argument
338 struct device *dev = &self->ndev->dev; sh_irda_sir_fre()
341 int len = sh_irda_get_rcv_length(self); sh_irda_sir_fre()
352 data16 = sh_irda_read(self, IRDARAM + i); sh_irda_sir_fre()
354 async_unwrap_char(self->ndev, &self->ndev->stats, sh_irda_sir_fre()
355 &self->rx_buff, data[j]); sh_irda_sir_fre()
357 self->ndev->last_rx = jiffies; sh_irda_sir_fre()
359 sh_irda_rcv_ctrl(self, 1); sh_irda_sir_fre()
364 static int sh_irda_sir_trov(struct sh_irda_self *self) sh_irda_sir_trov() argument
366 struct device *dev = &self->ndev->dev; sh_irda_sir_trov()
369 sh_irda_rcv_ctrl(self, 1); sh_irda_sir_trov()
373 static int sh_irda_sir_tot(struct sh_irda_self *self) sh_irda_sir_tot() argument
375 struct device *dev = &self->ndev->dev; sh_irda_sir_tot()
378 sh_irda_set_baudrate(self, 9600); sh_irda_sir_tot()
379 sh_irda_rcv_ctrl(self, 1); sh_irda_sir_tot()
383 static int sh_irda_sir_fer(struct sh_irda_self *self) sh_irda_sir_fer() argument
385 struct device *dev = &self->ndev->dev; sh_irda_sir_fer()
388 sh_irda_rcv_ctrl(self, 1); sh_irda_sir_fer()
392 static int sh_irda_sir_fte(struct sh_irda_self *self) sh_irda_sir_fte() argument
394 struct device *dev = &self->ndev->dev; sh_irda_sir_fte()
397 netif_wake_queue(self->ndev); sh_irda_sir_fte()
410 static void sh_irda_set_mode(struct sh_irda_self *self, enum sh_irda_mode mode) sh_irda_set_mode() argument
412 struct device *dev = &self->ndev->dev; sh_irda_set_mode()
440 self->mode = mode; sh_irda_set_mode()
441 self->xir_func = func; sh_irda_set_mode()
442 sh_irda_update_bits(self, IRTMR, TMD_MASK, data); sh_irda_set_mode()
454 static void sh_irda_set_irq_mask(struct sh_irda_self *self) sh_irda_set_irq_mask() argument
460 sh_irda_update_bits(self, IRTMR, xIM_MASK, xIM_MASK); sh_irda_set_irq_mask()
461 sh_irda_update_bits(self, SIRIMR, xIR_MASK, xIR_MASK); sh_irda_set_irq_mask()
462 sh_irda_update_bits(self, MFIRIMR, xIR_MASK, xIR_MASK); sh_irda_set_irq_mask()
465 sh_irda_update_bits(self, SIRICR, xIR_MASK, xIR_MASK); sh_irda_set_irq_mask()
466 sh_irda_update_bits(self, MFIRICR, xIR_MASK, xIR_MASK); sh_irda_set_irq_mask()
468 switch (self->mode) { sh_irda_set_irq_mask()
486 sh_irda_update_bits(self, IRTMR, tmr_hole, 0); sh_irda_set_irq_mask()
487 sh_irda_update_bits(self, xir_reg, xIR_MASK, 0); sh_irda_set_irq_mask()
493 struct sh_irda_self *self = dev_id; sh_irda_irq() local
494 struct sh_irda_xir_func *func = self->xir_func; sh_irda_irq()
495 u16 isr = sh_irda_read(self, SIRISR); sh_irda_irq()
498 sh_irda_write(self, SIRICR, isr); sh_irda_irq()
501 func->xir_fre(self); sh_irda_irq()
503 func->xir_trov(self); sh_irda_irq()
505 func->xir_9(self); sh_irda_irq()
507 func->xir_8(self); sh_irda_irq()
509 func->xir_fte(self); sh_irda_irq()
521 static void sh_irda_crc_reset(struct sh_irda_self *self) sh_irda_crc_reset() argument
523 sh_irda_write(self, CRCCTR, CRC_RST); sh_irda_crc_reset()
526 static void sh_irda_crc_add(struct sh_irda_self *self, u16 data) sh_irda_crc_add() argument
528 sh_irda_write(self, CRCIR, data & CRC_IN_MASK); sh_irda_crc_add()
531 static u16 sh_irda_crc_cnt(struct sh_irda_self *self) sh_irda_crc_cnt() argument
533 return CRC_CT_MASK & sh_irda_read(self, CRCCTR); sh_irda_crc_cnt()
536 static u16 sh_irda_crc_out(struct sh_irda_self *self) sh_irda_crc_out() argument
538 return sh_irda_read(self, CRCOR); sh_irda_crc_out()
541 static int sh_irda_crc_init(struct sh_irda_self *self) sh_irda_crc_init() argument
543 struct device *dev = &self->ndev->dev; sh_irda_crc_init()
547 sh_irda_crc_reset(self); sh_irda_crc_init()
549 sh_irda_crc_add(self, 0xCC); sh_irda_crc_init()
550 sh_irda_crc_add(self, 0xF5); sh_irda_crc_init()
551 sh_irda_crc_add(self, 0xF1); sh_irda_crc_init()
552 sh_irda_crc_add(self, 0xA7); sh_irda_crc_init()
554 val = sh_irda_crc_cnt(self); sh_irda_crc_init()
560 val = sh_irda_crc_out(self); sh_irda_crc_init()
570 sh_irda_crc_reset(self); sh_irda_crc_init()
581 static void sh_irda_remove_iobuf(struct sh_irda_self *self) sh_irda_remove_iobuf() argument
583 kfree(self->rx_buff.head); sh_irda_remove_iobuf()
585 self->tx_buff.head = NULL; sh_irda_remove_iobuf()
586 self->tx_buff.data = NULL; sh_irda_remove_iobuf()
587 self->rx_buff.head = NULL; sh_irda_remove_iobuf()
588 self->rx_buff.data = NULL; sh_irda_remove_iobuf()
591 static int sh_irda_init_iobuf(struct sh_irda_self *self, int rxsize, int txsize) sh_irda_init_iobuf() argument
593 if (self->rx_buff.head || sh_irda_init_iobuf()
594 self->tx_buff.head) { sh_irda_init_iobuf()
595 dev_err(&self->ndev->dev, "iobuff has already existed."); sh_irda_init_iobuf()
600 self->rx_buff.head = kmalloc(rxsize, GFP_KERNEL); sh_irda_init_iobuf()
601 if (!self->rx_buff.head) sh_irda_init_iobuf()
604 self->rx_buff.truesize = rxsize; sh_irda_init_iobuf()
605 self->rx_buff.in_frame = FALSE; sh_irda_init_iobuf()
606 self->rx_buff.state = OUTSIDE_FRAME; sh_irda_init_iobuf()
607 self->rx_buff.data = self->rx_buff.head; sh_irda_init_iobuf()
610 self->tx_buff.head = self->membase + IRDARAM; sh_irda_init_iobuf()
611 self->tx_buff.truesize = IRDARAM_LEN; sh_irda_init_iobuf()
625 struct sh_irda_self *self = netdev_priv(ndev); sh_irda_hard_xmit() local
626 struct device *dev = &self->ndev->dev; sh_irda_hard_xmit()
633 sh_irda_rcv_ctrl(self, 0); sh_irda_hard_xmit()
635 ret = sh_irda_set_baudrate(self, speed); sh_irda_hard_xmit()
639 self->tx_buff.len = 0; sh_irda_hard_xmit()
643 spin_lock_irqsave(&self->lock, flags); sh_irda_hard_xmit()
644 self->tx_buff.len = async_wrap_skb(skb, sh_irda_hard_xmit()
645 self->tx_buff.head, sh_irda_hard_xmit()
646 self->tx_buff.truesize); sh_irda_hard_xmit()
647 spin_unlock_irqrestore(&self->lock, flags); sh_irda_hard_xmit()
649 if (self->tx_buff.len > self->tx_buff.truesize) sh_irda_hard_xmit()
650 self->tx_buff.len = self->tx_buff.truesize; sh_irda_hard_xmit()
652 sh_irda_write(self, IRTFLR, self->tx_buff.len); sh_irda_hard_xmit()
653 sh_irda_write(self, IRTCTR, ARMOD | TE); sh_irda_hard_xmit()
662 sh_irda_set_baudrate(self, 9600); sh_irda_hard_xmit()
663 netif_wake_queue(self->ndev); sh_irda_hard_xmit()
664 sh_irda_rcv_ctrl(self, 1); sh_irda_hard_xmit()
684 struct sh_irda_self *self = netdev_priv(ndev); sh_irda_stats() local
686 return &self->ndev->stats; sh_irda_stats()
691 struct sh_irda_self *self = netdev_priv(ndev); sh_irda_open() local
694 pm_runtime_get_sync(&self->pdev->dev); sh_irda_open()
695 err = sh_irda_crc_init(self); sh_irda_open()
699 sh_irda_set_mode(self, SH_IRDA_SIR); sh_irda_open()
700 sh_irda_set_timeout(self, 2); sh_irda_open()
701 sh_irda_set_baudrate(self, 9600); sh_irda_open()
703 self->irlap = irlap_open(ndev, &self->qos, DRIVER_NAME); sh_irda_open()
704 if (!self->irlap) { sh_irda_open()
710 sh_irda_rcv_ctrl(self, 1); sh_irda_open()
711 sh_irda_set_irq_mask(self); sh_irda_open()
718 pm_runtime_put_sync(&self->pdev->dev); sh_irda_open()
725 struct sh_irda_self *self = netdev_priv(ndev); sh_irda_stop() local
728 if (self->irlap) { sh_irda_stop()
729 irlap_close(self->irlap); sh_irda_stop()
730 self->irlap = NULL; sh_irda_stop()
734 pm_runtime_put_sync(&self->pdev->dev); sh_irda_stop()
759 struct sh_irda_self *self; sh_irda_probe() local
771 ndev = alloc_irdadev(sizeof(*self)); sh_irda_probe()
775 self = netdev_priv(ndev); sh_irda_probe()
776 self->membase = ioremap_nocache(res->start, resource_size(res)); sh_irda_probe()
777 if (!self->membase) { sh_irda_probe()
783 err = sh_irda_init_iobuf(self, IRDA_SKB_MAX_MTU, IRDA_SIR_MAX_FRAME); sh_irda_probe()
787 self->pdev = pdev; sh_irda_probe()
790 irda_init_max_qos_capabilies(&self->qos); sh_irda_probe()
795 self->ndev = ndev; sh_irda_probe()
796 self->qos.baud_rate.bits &= IR_9600; /* FIXME */ sh_irda_probe()
797 self->qos.min_turn_time.bits = 1; /* 10 ms or more */ sh_irda_probe()
798 spin_lock_init(&self->lock); sh_irda_probe()
800 irda_qos_bits_to_value(&self->qos); sh_irda_probe()
807 err = devm_request_irq(&pdev->dev, irq, sh_irda_irq, 0, "sh_irda", self); sh_irda_probe()
819 sh_irda_remove_iobuf(self); sh_irda_probe()
821 iounmap(self->membase); sh_irda_probe()
831 struct sh_irda_self *self = netdev_priv(ndev); sh_irda_remove() local
833 if (!self) sh_irda_remove()
838 sh_irda_remove_iobuf(self); sh_irda_remove()
839 iounmap(self->membase); sh_irda_remove()
|
| H A D | via-ircc.c | 81 static int via_ircc_dma_receive(struct via_ircc_cb *self);
82 static int via_ircc_dma_receive_complete(struct via_ircc_cb *self,
88 static void via_hw_init(struct via_ircc_cb *self);
89 static void via_ircc_change_speed(struct via_ircc_cb *self, __u32 baud);
91 static int via_ircc_is_receiving(struct via_ircc_cb *self);
100 static int RxTimerHandler(struct via_ircc_cb *self, int iobase);
101 static void hwreset(struct via_ircc_cb *self);
102 static int via_ircc_dma_xmit(struct via_ircc_cb *self, u16 iobase);
103 static int upload_rxdata(struct via_ircc_cb *self, int iobase);
285 struct via_ircc_cb *self; via_ircc_open() local
293 self = netdev_priv(dev); via_ircc_open()
294 self->netdev = dev; via_ircc_open()
295 spin_lock_init(&self->lock); via_ircc_open()
297 pci_set_drvdata(pdev, self); via_ircc_open()
300 self->io.cfg_base = info->cfg_base; via_ircc_open()
301 self->io.fir_base = info->fir_base; via_ircc_open()
302 self->io.irq = info->irq; via_ircc_open()
303 self->io.fir_ext = CHIP_IO_EXTENT; via_ircc_open()
304 self->io.dma = info->dma; via_ircc_open()
305 self->io.dma2 = info->dma2; via_ircc_open()
306 self->io.fifo_size = 32; via_ircc_open()
307 self->chip_id = id; via_ircc_open()
308 self->st_fifo.len = 0; via_ircc_open()
309 self->RxDataReady = 0; via_ircc_open()
312 if (!request_region(self->io.fir_base, self->io.fir_ext, driver_name)) { via_ircc_open()
314 __func__, self->io.fir_base); via_ircc_open()
320 irda_init_max_qos_capabilies(&self->qos); via_ircc_open()
324 dongle_id = via_ircc_read_dongle_id(self->io.fir_base); via_ircc_open()
325 self->io.dongle_id = dongle_id; via_ircc_open()
329 switch( self->io.dongle_id ){ via_ircc_open()
331 self->qos.baud_rate.bits = via_ircc_open()
336 self->qos.baud_rate.bits = via_ircc_open()
343 * self->qos.baud_rate.bits = IR_9600; via_ircc_open()
348 self->qos.min_turn_time.bits = qos_mtt_bits; via_ircc_open()
349 irda_qos_bits_to_value(&self->qos); via_ircc_open()
352 self->rx_buff.truesize = 14384 + 2048; via_ircc_open()
353 self->tx_buff.truesize = 14384 + 2048; via_ircc_open()
356 self->rx_buff.head = via_ircc_open()
357 dma_zalloc_coherent(&pdev->dev, self->rx_buff.truesize, via_ircc_open()
358 &self->rx_buff_dma, GFP_KERNEL); via_ircc_open()
359 if (self->rx_buff.head == NULL) { via_ircc_open()
364 self->tx_buff.head = via_ircc_open()
365 dma_zalloc_coherent(&pdev->dev, self->tx_buff.truesize, via_ircc_open()
366 &self->tx_buff_dma, GFP_KERNEL); via_ircc_open()
367 if (self->tx_buff.head == NULL) { via_ircc_open()
372 self->rx_buff.in_frame = FALSE; via_ircc_open()
373 self->rx_buff.state = OUTSIDE_FRAME; via_ircc_open()
374 self->tx_buff.data = self->tx_buff.head; via_ircc_open()
375 self->rx_buff.data = self->rx_buff.head; via_ircc_open()
378 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; via_ircc_open()
379 self->tx_fifo.tail = self->tx_buff.head; via_ircc_open()
393 self->io.speed = 9600; via_ircc_open()
394 via_hw_init(self); via_ircc_open()
397 dma_free_coherent(&pdev->dev, self->tx_buff.truesize, via_ircc_open()
398 self->tx_buff.head, self->tx_buff_dma); via_ircc_open()
400 dma_free_coherent(&pdev->dev, self->rx_buff.truesize, via_ircc_open()
401 self->rx_buff.head, self->rx_buff_dma); via_ircc_open()
403 release_region(self->io.fir_base, self->io.fir_ext); via_ircc_open()
417 struct via_ircc_cb *self = pci_get_drvdata(pdev); via_remove_one() local
420 iobase = self->io.fir_base; via_remove_one()
424 unregister_netdev(self->netdev); via_remove_one()
428 __func__, self->io.fir_base); via_remove_one()
429 release_region(self->io.fir_base, self->io.fir_ext); via_remove_one()
430 if (self->tx_buff.head) via_remove_one()
431 dma_free_coherent(&pdev->dev, self->tx_buff.truesize, via_remove_one()
432 self->tx_buff.head, self->tx_buff_dma); via_remove_one()
433 if (self->rx_buff.head) via_remove_one()
434 dma_free_coherent(&pdev->dev, self->rx_buff.truesize, via_remove_one()
435 self->rx_buff.head, self->rx_buff_dma); via_remove_one()
437 free_netdev(self->netdev); via_remove_one()
443 * Function via_hw_init(self)
449 static void via_hw_init(struct via_ircc_cb *self) via_hw_init() argument
451 int iobase = self->io.fir_base; via_hw_init()
489 self->io.speed = 9600; via_hw_init()
490 self->st_fifo.len = 0; via_hw_init()
492 via_ircc_change_dongle_speed(iobase, self->io.speed, via_hw_init()
493 self->io.dongle_id); via_hw_init()
654 * Function via_ircc_change_speed (self, baud)
659 static void via_ircc_change_speed(struct via_ircc_cb *self, __u32 speed) via_ircc_change_speed() argument
661 struct net_device *dev = self->netdev; via_ircc_change_speed()
665 iobase = self->io.fir_base; via_ircc_change_speed()
667 self->io.speed = speed; via_ircc_change_speed()
720 via_ircc_change_dongle_speed(iobase, speed, self->io.dongle_id); via_ircc_change_speed()
744 via_ircc_dma_receive(self); via_ircc_change_speed()
761 struct via_ircc_cb *self; via_ircc_hard_xmit_sir() local
766 self = netdev_priv(dev); via_ircc_hard_xmit_sir()
767 IRDA_ASSERT(self != NULL, return NETDEV_TX_OK;); via_ircc_hard_xmit_sir()
768 iobase = self->io.fir_base; via_ircc_hard_xmit_sir()
773 if ((speed != self->io.speed) && (speed != -1)) { via_ircc_hard_xmit_sir()
776 via_ircc_change_speed(self, speed); via_ircc_hard_xmit_sir()
781 self->new_speed = speed; via_ircc_hard_xmit_sir()
791 spin_lock_irqsave(&self->lock, flags); via_ircc_hard_xmit_sir()
792 self->tx_buff.data = self->tx_buff.head; via_ircc_hard_xmit_sir()
793 self->tx_buff.len = via_ircc_hard_xmit_sir()
794 async_wrap_skb(skb, self->tx_buff.data, via_ircc_hard_xmit_sir()
795 self->tx_buff.truesize); via_ircc_hard_xmit_sir()
797 dev->stats.tx_bytes += self->tx_buff.len; via_ircc_hard_xmit_sir()
799 SetBaudRate(iobase, self->io.speed); via_ircc_hard_xmit_sir()
817 irda_setup_dma(self->io.dma, self->tx_buff_dma, self->tx_buff.len, via_ircc_hard_xmit_sir()
820 SetSendByte(iobase, self->tx_buff.len); via_ircc_hard_xmit_sir()
825 spin_unlock_irqrestore(&self->lock, flags); via_ircc_hard_xmit_sir()
833 struct via_ircc_cb *self; via_ircc_hard_xmit_fir() local
838 self = netdev_priv(dev); via_ircc_hard_xmit_fir()
839 iobase = self->io.fir_base; via_ircc_hard_xmit_fir()
841 if (self->st_fifo.len) via_ircc_hard_xmit_fir()
843 if (self->chip_id == 0x3076) via_ircc_hard_xmit_fir()
849 if ((speed != self->io.speed) && (speed != -1)) { via_ircc_hard_xmit_fir()
851 via_ircc_change_speed(self, speed); via_ircc_hard_xmit_fir()
856 self->new_speed = speed; via_ircc_hard_xmit_fir()
858 spin_lock_irqsave(&self->lock, flags); via_ircc_hard_xmit_fir()
859 self->tx_fifo.queue[self->tx_fifo.free].start = self->tx_fifo.tail; via_ircc_hard_xmit_fir()
860 self->tx_fifo.queue[self->tx_fifo.free].len = skb->len; via_ircc_hard_xmit_fir()
862 self->tx_fifo.tail += skb->len; via_ircc_hard_xmit_fir()
865 self->tx_fifo.queue[self->tx_fifo.free].start, skb->len); via_ircc_hard_xmit_fir()
866 self->tx_fifo.len++; via_ircc_hard_xmit_fir()
867 self->tx_fifo.free++; via_ircc_hard_xmit_fir()
868 //F01 if (self->tx_fifo.len == 1) { via_ircc_hard_xmit_fir()
869 via_ircc_dma_xmit(self, iobase); via_ircc_hard_xmit_fir()
871 //F01 if (self->tx_fifo.free < (MAX_TX_WINDOW -1 )) netif_wake_queue(self->netdev); via_ircc_hard_xmit_fir()
874 spin_unlock_irqrestore(&self->lock, flags); via_ircc_hard_xmit_fir()
879 static int via_ircc_dma_xmit(struct via_ircc_cb *self, u16 iobase) via_ircc_dma_xmit() argument
882 self->io.direction = IO_XMIT; via_ircc_dma_xmit()
894 irda_setup_dma(self->io.dma, via_ircc_dma_xmit()
895 ((u8 *)self->tx_fifo.queue[self->tx_fifo.ptr].start - via_ircc_dma_xmit()
896 self->tx_buff.head) + self->tx_buff_dma, via_ircc_dma_xmit()
897 self->tx_fifo.queue[self->tx_fifo.ptr].len, DMA_TX_MODE); via_ircc_dma_xmit()
899 __func__, self->tx_fifo.ptr, via_ircc_dma_xmit()
900 self->tx_fifo.queue[self->tx_fifo.ptr].len, via_ircc_dma_xmit()
901 self->tx_fifo.len); via_ircc_dma_xmit()
903 SetSendByte(iobase, self->tx_fifo.queue[self->tx_fifo.ptr].len); via_ircc_dma_xmit()
911 * Function via_ircc_dma_xmit_complete (self)
917 static int via_ircc_dma_xmit_complete(struct via_ircc_cb *self) via_ircc_dma_xmit_complete() argument
922 iobase = self->io.fir_base; via_ircc_dma_xmit_complete()
924 // DisableDmaChannel(self->io.dma); via_ircc_dma_xmit_complete()
929 self->netdev->stats.tx_errors++; via_ircc_dma_xmit_complete()
930 self->netdev->stats.tx_fifo_errors++; via_ircc_dma_xmit_complete()
931 hwreset(self); via_ircc_dma_xmit_complete()
934 self->netdev->stats.tx_packets++; via_ircc_dma_xmit_complete()
939 if (self->new_speed) { via_ircc_dma_xmit_complete()
940 via_ircc_change_speed(self, self->new_speed); via_ircc_dma_xmit_complete()
941 self->new_speed = 0; via_ircc_dma_xmit_complete()
946 if (self->tx_fifo.len) { via_ircc_dma_xmit_complete()
947 self->tx_fifo.len--; via_ircc_dma_xmit_complete()
948 self->tx_fifo.ptr++; via_ircc_dma_xmit_complete()
953 self->tx_fifo.len, self->tx_fifo.ptr, self->tx_fifo.free); via_ircc_dma_xmit_complete()
956 if (self->tx_fifo.len) { via_ircc_dma_xmit_complete()
958 via_ircc_dma_xmit(self, iobase); via_ircc_dma_xmit_complete()
963 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; via_ircc_dma_xmit_complete()
964 self->tx_fifo.tail = self->tx_buff.head; via_ircc_dma_xmit_complete()
968 //F01 if (self->tx_fifo.free < (MAX_TX_WINDOW -1 )) { via_ircc_dma_xmit_complete()
971 netif_wake_queue(self->netdev); via_ircc_dma_xmit_complete()
977 * Function via_ircc_dma_receive (self)
982 static int via_ircc_dma_receive(struct via_ircc_cb *self) via_ircc_dma_receive() argument
986 iobase = self->io.fir_base; via_ircc_dma_receive()
988 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; via_ircc_dma_receive()
989 self->tx_fifo.tail = self->tx_buff.head; via_ircc_dma_receive()
990 self->RxDataReady = 0; via_ircc_dma_receive()
991 self->io.direction = IO_RECV; via_ircc_dma_receive()
992 self->rx_buff.data = self->rx_buff.head; via_ircc_dma_receive()
993 self->st_fifo.len = self->st_fifo.pending_bytes = 0; via_ircc_dma_receive()
994 self->st_fifo.tail = self->st_fifo.head = 0; via_ircc_dma_receive()
1009 irda_setup_dma(self->io.dma2, self->rx_buff_dma, via_ircc_dma_receive()
1010 self->rx_buff.truesize, DMA_RX_MODE); via_ircc_dma_receive()
1018 * Function via_ircc_dma_receive_complete (self)
1024 static int via_ircc_dma_receive_complete(struct via_ircc_cb *self, via_ircc_dma_receive_complete() argument
1032 iobase = self->io.fir_base; via_ircc_dma_receive_complete()
1033 st_fifo = &self->st_fifo; via_ircc_dma_receive_complete()
1035 if (self->io.speed < 4000000) { //Speed below FIR via_ircc_dma_receive_complete()
1036 len = GetRecvByte(iobase, self); via_ircc_dma_receive_complete()
1043 if (self->chip_id == 0x3076) { via_ircc_dma_receive_complete()
1045 skb->data[i] = self->rx_buff.data[i * 2]; via_ircc_dma_receive_complete()
1047 if (self->chip_id == 0x3096) { via_ircc_dma_receive_complete()
1050 self->rx_buff.data[i]; via_ircc_dma_receive_complete()
1054 self->rx_buff.data += len; via_ircc_dma_receive_complete()
1055 self->netdev->stats.rx_bytes += len; via_ircc_dma_receive_complete()
1056 self->netdev->stats.rx_packets++; via_ircc_dma_receive_complete()
1057 skb->dev = self->netdev; via_ircc_dma_receive_complete()
1065 len = GetRecvByte(iobase, self); via_ircc_dma_receive_complete()
1070 __func__, len, RxCurCount(iobase, self), via_ircc_dma_receive_complete()
1071 self->RxLastCount); via_ircc_dma_receive_complete()
1072 hwreset(self); via_ircc_dma_receive_complete()
1077 st_fifo->len, len - 4, RxCurCount(iobase, self)); via_ircc_dma_receive_complete()
1086 self->RxDataReady = 0; via_ircc_dma_receive_complete()
1115 (self->rx_buff.data == NULL) || (len < 6)) { via_ircc_dma_receive_complete()
1116 self->netdev->stats.rx_dropped++; via_ircc_dma_receive_complete()
1123 skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4); via_ircc_dma_receive_complete()
1125 len - 4, self->rx_buff.data); via_ircc_dma_receive_complete()
1128 self->rx_buff.data += len; via_ircc_dma_receive_complete()
1129 self->netdev->stats.rx_bytes += len; via_ircc_dma_receive_complete()
1130 self->netdev->stats.rx_packets++; via_ircc_dma_receive_complete()
1131 skb->dev = self->netdev; via_ircc_dma_receive_complete()
1145 static int upload_rxdata(struct via_ircc_cb *self, int iobase) upload_rxdata() argument
1150 st_fifo = &self->st_fifo; upload_rxdata()
1152 len = GetRecvByte(iobase, self); upload_rxdata()
1157 self->netdev->stats.rx_dropped++; upload_rxdata()
1163 self->netdev->stats.rx_dropped++; upload_rxdata()
1168 skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4 + 1); upload_rxdata()
1174 self->rx_buff.data += len; upload_rxdata()
1175 self->netdev->stats.rx_bytes += len; upload_rxdata()
1176 self->netdev->stats.rx_packets++; upload_rxdata()
1177 skb->dev = self->netdev; upload_rxdata()
1195 static int RxTimerHandler(struct via_ircc_cb *self, int iobase) RxTimerHandler() argument
1202 st_fifo = &self->st_fifo; RxTimerHandler()
1204 if (CkRxRecv(iobase, self)) { RxTimerHandler()
1206 self->RetryCount = 0; RxTimerHandler()
1208 self->RxDataReady++; RxTimerHandler()
1211 self->RetryCount++; RxTimerHandler()
1213 if ((self->RetryCount >= 1) || RxTimerHandler()
1214 ((st_fifo->pending_bytes + 2048) > self->rx_buff.truesize) || RxTimerHandler()
1231 (self->rx_buff.data == NULL) || (len < 6)) { RxTimerHandler()
1232 self->netdev->stats.rx_dropped++; RxTimerHandler()
1237 skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4); RxTimerHandler()
1243 self->rx_buff.data += len; RxTimerHandler()
1244 self->netdev->stats.rx_bytes += len; RxTimerHandler()
1245 self->netdev->stats.rx_packets++; RxTimerHandler()
1246 skb->dev = self->netdev; RxTimerHandler()
1251 self->RetryCount = 0; RxTimerHandler()
1261 (RxCurCount(iobase, self) != self->RxLastCount)) { RxTimerHandler()
1262 upload_rxdata(self, iobase); RxTimerHandler()
1263 if (irda_device_txqueue_empty(self->netdev)) RxTimerHandler()
1264 via_ircc_dma_receive(self); RxTimerHandler()
1284 struct via_ircc_cb *self = netdev_priv(dev); via_ircc_interrupt() local
1288 iobase = self->io.fir_base; via_ircc_interrupt()
1289 spin_lock(&self->lock); via_ircc_interrupt()
1300 self->EventFlag.TimeOut++; via_ircc_interrupt()
1302 if (self->io.direction == IO_XMIT) { via_ircc_interrupt()
1303 via_ircc_dma_xmit(self, iobase); via_ircc_interrupt()
1305 if (self->io.direction == IO_RECV) { via_ircc_interrupt()
1309 if (self->RxDataReady > 30) { via_ircc_interrupt()
1310 hwreset(self); via_ircc_interrupt()
1311 if (irda_device_txqueue_empty(self->netdev)) { via_ircc_interrupt()
1312 via_ircc_dma_receive(self); via_ircc_interrupt()
1315 RxTimerHandler(self, iobase); via_ircc_interrupt()
1330 self->EventFlag.EOMessage++; // read and will auto clean via_ircc_interrupt()
1331 if (via_ircc_dma_xmit_complete(self)) { via_ircc_interrupt()
1333 (self->netdev)) { via_ircc_interrupt()
1334 via_ircc_dma_receive(self); via_ircc_interrupt()
1337 self->EventFlag.Unknown++; via_ircc_interrupt()
1359 if (via_ircc_dma_receive_complete(self, iobase)) { via_ircc_interrupt()
1360 //F01 if(!(IsFIROn(iobase))) via_ircc_dma_receive(self); via_ircc_interrupt()
1361 via_ircc_dma_receive(self); via_ircc_interrupt()
1367 RxCurCount(iobase, self), self->RxLastCount); via_ircc_interrupt()
1375 hwreset(self); //F01 via_ircc_interrupt()
1377 via_ircc_dma_receive(self); via_ircc_interrupt()
1381 spin_unlock(&self->lock); via_ircc_interrupt()
1385 static void hwreset(struct via_ircc_cb *self) hwreset() argument
1388 iobase = self->io.fir_base; hwreset()
1411 via_ircc_change_speed(self, self->io.speed); hwreset()
1413 self->st_fifo.len = 0; hwreset()
1417 * Function via_ircc_is_receiving (self)
1422 static int via_ircc_is_receiving(struct via_ircc_cb *self) via_ircc_is_receiving() argument
1427 IRDA_ASSERT(self != NULL, return FALSE;); via_ircc_is_receiving()
1429 iobase = self->io.fir_base; via_ircc_is_receiving()
1430 if (CkRxRecv(iobase, self)) via_ircc_is_receiving()
1447 struct via_ircc_cb *self; via_ircc_net_open() local
1452 self = netdev_priv(dev); via_ircc_net_open()
1454 IRDA_ASSERT(self != NULL, return 0;); via_ircc_net_open()
1455 iobase = self->io.fir_base; via_ircc_net_open()
1456 if (request_irq(self->io.irq, via_ircc_interrupt, 0, dev->name, dev)) { via_ircc_net_open()
1458 driver_name, self->io.irq); via_ircc_net_open()
1465 if (request_dma(self->io.dma, dev->name)) { via_ircc_net_open()
1467 driver_name, self->io.dma); via_ircc_net_open()
1468 free_irq(self->io.irq, dev); via_ircc_net_open()
1471 if (self->io.dma2 != self->io.dma) { via_ircc_net_open()
1472 if (request_dma(self->io.dma2, dev->name)) { via_ircc_net_open()
1474 driver_name, self->io.dma2); via_ircc_net_open()
1475 free_irq(self->io.irq, dev); via_ircc_net_open()
1476 free_dma(self->io.dma); via_ircc_net_open()
1488 via_ircc_dma_receive(self); via_ircc_net_open()
1498 self->irlap = irlap_open(dev, &self->qos, hwname); via_ircc_net_open()
1500 self->RxLastCount = 0; via_ircc_net_open()
1513 struct via_ircc_cb *self; via_ircc_net_close() local
1517 self = netdev_priv(dev); via_ircc_net_close()
1518 IRDA_ASSERT(self != NULL, return 0;); via_ircc_net_close()
1523 if (self->irlap) via_ircc_net_close()
1524 irlap_close(self->irlap); via_ircc_net_close()
1525 self->irlap = NULL; via_ircc_net_close()
1526 iobase = self->io.fir_base; via_ircc_net_close()
1529 DisableDmaChannel(self->io.dma); via_ircc_net_close()
1533 free_irq(self->io.irq, dev); via_ircc_net_close()
1534 free_dma(self->io.dma); via_ircc_net_close()
1535 if (self->io.dma2 != self->io.dma) via_ircc_net_close()
1536 free_dma(self->io.dma2); via_ircc_net_close()
1551 struct via_ircc_cb *self; via_ircc_net_ioctl() local
1556 self = netdev_priv(dev); via_ircc_net_ioctl()
1557 IRDA_ASSERT(self != NULL, return -1;); via_ircc_net_ioctl()
1561 spin_lock_irqsave(&self->lock, flags); via_ircc_net_ioctl()
1568 via_ircc_change_speed(self, irq->ifr_baudrate); via_ircc_net_ioctl()
1575 irda_device_set_media_busy(self->netdev, TRUE); via_ircc_net_ioctl()
1578 irq->ifr_receiving = via_ircc_is_receiving(self); via_ircc_net_ioctl()
1584 spin_unlock_irqrestore(&self->lock, flags); via_ircc_net_ioctl()
|
| H A D | w83977af_ir.c | 88 static int w83977af_close(struct w83977af_ir *self);
90 static int w83977af_dma_receive(struct w83977af_ir *self);
91 static int w83977af_dma_receive_complete(struct w83977af_ir *self);
95 static void w83977af_dma_write(struct w83977af_ir *self, int iobase);
96 static void w83977af_change_speed(struct w83977af_ir *self, __u32 speed);
97 static int w83977af_is_receiving(struct w83977af_ir *self);
153 struct w83977af_ir *self; w83977af_open() local
178 self = netdev_priv(dev); w83977af_open()
179 spin_lock_init(&self->lock); w83977af_open()
183 self->io.fir_base = iobase; w83977af_open()
184 self->io.irq = irq; w83977af_open()
185 self->io.fir_ext = CHIP_IO_EXTENT; w83977af_open()
186 self->io.dma = dma; w83977af_open()
187 self->io.fifo_size = 32; w83977af_open()
190 irda_init_max_qos_capabilies(&self->qos); w83977af_open()
195 self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600| w83977af_open()
199 self->qos.min_turn_time.bits = qos_mtt_bits; w83977af_open()
200 irda_qos_bits_to_value(&self->qos); w83977af_open()
203 self->rx_buff.truesize = 14384; w83977af_open()
204 self->tx_buff.truesize = 4000; w83977af_open()
207 self->rx_buff.head = w83977af_open()
208 dma_zalloc_coherent(NULL, self->rx_buff.truesize, w83977af_open()
209 &self->rx_buff_dma, GFP_KERNEL); w83977af_open()
210 if (self->rx_buff.head == NULL) { w83977af_open()
215 self->tx_buff.head = w83977af_open()
216 dma_zalloc_coherent(NULL, self->tx_buff.truesize, w83977af_open()
217 &self->tx_buff_dma, GFP_KERNEL); w83977af_open()
218 if (self->tx_buff.head == NULL) { w83977af_open()
223 self->rx_buff.in_frame = FALSE; w83977af_open()
224 self->rx_buff.state = OUTSIDE_FRAME; w83977af_open()
225 self->tx_buff.data = self->tx_buff.head; w83977af_open()
226 self->rx_buff.data = self->rx_buff.head; w83977af_open()
227 self->netdev = dev; w83977af_open()
239 /* Need to store self somewhere */ w83977af_open()
240 dev_self[i] = self; w83977af_open()
244 dma_free_coherent(NULL, self->tx_buff.truesize, w83977af_open()
245 self->tx_buff.head, self->tx_buff_dma); w83977af_open()
247 dma_free_coherent(NULL, self->rx_buff.truesize, w83977af_open()
248 self->rx_buff.head, self->rx_buff_dma); w83977af_open()
257 * Function w83977af_close (self)
262 static int w83977af_close(struct w83977af_ir *self) w83977af_close() argument
266 iobase = self->io.fir_base; w83977af_close()
281 unregister_netdev(self->netdev); w83977af_close()
285 __func__ , self->io.fir_base); w83977af_close()
286 release_region(self->io.fir_base, self->io.fir_ext); w83977af_close()
288 if (self->tx_buff.head) w83977af_close()
289 dma_free_coherent(NULL, self->tx_buff.truesize, w83977af_close()
290 self->tx_buff.head, self->tx_buff_dma); w83977af_close()
292 if (self->rx_buff.head) w83977af_close()
293 dma_free_coherent(NULL, self->rx_buff.truesize, w83977af_close()
294 self->rx_buff.head, self->rx_buff_dma); w83977af_close()
296 free_netdev(self->netdev); w83977af_close()
399 static void w83977af_change_speed(struct w83977af_ir *self, __u32 speed) w83977af_change_speed() argument
405 iobase = self->io.fir_base; w83977af_change_speed()
408 self->io.speed = speed; w83977af_change_speed()
459 netif_wake_queue(self->netdev); w83977af_change_speed()
465 w83977af_dma_receive(self); w83977af_change_speed()
482 struct w83977af_ir *self; w83977af_hard_xmit() local
488 self = netdev_priv(dev); w83977af_hard_xmit()
490 iobase = self->io.fir_base; w83977af_hard_xmit()
500 if ((speed != self->io.speed) && (speed != -1)) { w83977af_hard_xmit()
503 w83977af_change_speed(self, speed); w83977af_hard_xmit()
507 self->new_speed = speed; w83977af_hard_xmit()
514 if (self->io.speed > PIO_MAX_SPEED) { w83977af_hard_xmit()
515 self->tx_buff.data = self->tx_buff.head; w83977af_hard_xmit()
516 skb_copy_from_linear_data(skb, self->tx_buff.data, skb->len); w83977af_hard_xmit()
517 self->tx_buff.len = skb->len; w83977af_hard_xmit()
527 w83977af_dma_write(self, iobase); w83977af_hard_xmit()
529 self->tx_buff.data = self->tx_buff.head; w83977af_hard_xmit()
530 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, w83977af_hard_xmit()
531 self->tx_buff.truesize); w83977af_hard_xmit()
546 * Function w83977af_dma_write (self, iobase)
551 static void w83977af_dma_write(struct w83977af_ir *self, int iobase) w83977af_dma_write() argument
554 pr_debug("%s(), len=%d\n", __func__ , self->tx_buff.len); w83977af_dma_write()
566 irda_setup_dma(self->io.dma, self->tx_buff_dma, self->tx_buff.len, w83977af_dma_write()
568 self->io.direction = IO_XMIT; w83977af_dma_write()
617 * Function w83977af_dma_xmit_complete (self)
623 static void w83977af_dma_xmit_complete(struct w83977af_ir *self) w83977af_dma_xmit_complete() argument
630 IRDA_ASSERT(self != NULL, return;); w83977af_dma_xmit_complete()
632 iobase = self->io.fir_base; w83977af_dma_xmit_complete()
645 self->netdev->stats.tx_errors++; w83977af_dma_xmit_complete()
646 self->netdev->stats.tx_fifo_errors++; w83977af_dma_xmit_complete()
651 self->netdev->stats.tx_packets++; w83977af_dma_xmit_complete()
654 if (self->new_speed) { w83977af_dma_xmit_complete()
655 w83977af_change_speed(self, self->new_speed); w83977af_dma_xmit_complete()
656 self->new_speed = 0; w83977af_dma_xmit_complete()
661 netif_wake_queue(self->netdev); w83977af_dma_xmit_complete()
668 * Function w83977af_dma_receive (self)
674 static int w83977af_dma_receive(struct w83977af_ir *self) w83977af_dma_receive() argument
682 IRDA_ASSERT(self != NULL, return -1;); w83977af_dma_receive()
686 iobase= self->io.fir_base; w83977af_dma_receive()
700 self->io.direction = IO_RECV; w83977af_dma_receive()
701 self->rx_buff.data = self->rx_buff.head; w83977af_dma_receive()
704 spin_lock_irqsave(&self->lock, flags); w83977af_dma_receive()
706 disable_dma(self->io.dma); w83977af_dma_receive()
707 clear_dma_ff(self->io.dma); w83977af_dma_receive()
708 set_dma_mode(self->io.dma, DMA_MODE_READ); w83977af_dma_receive()
709 set_dma_addr(self->io.dma, self->rx_buff_dma); w83977af_dma_receive()
710 set_dma_count(self->io.dma, self->rx_buff.truesize); w83977af_dma_receive()
712 irda_setup_dma(self->io.dma, self->rx_buff_dma, self->rx_buff.truesize, w83977af_dma_receive()
722 self->st_fifo.len = self->st_fifo.tail = self->st_fifo.head = 0; w83977af_dma_receive()
729 enable_dma(self->io.dma); w83977af_dma_receive()
730 spin_unlock_irqrestore(&self->lock, flags); w83977af_dma_receive()
741 * Function w83977af_receive_complete (self)
746 static int w83977af_dma_receive_complete(struct w83977af_ir *self) w83977af_dma_receive_complete() argument
757 st_fifo = &self->st_fifo; w83977af_dma_receive_complete()
759 iobase = self->io.fir_base; w83977af_dma_receive_complete()
764 iobase = self->io.fir_base; w83977af_dma_receive_complete()
789 self->netdev->stats.rx_errors += len; w83977af_dma_receive_complete()
792 self->netdev->stats.rx_errors++; w83977af_dma_receive_complete()
794 self->rx_buff.data += len; w83977af_dma_receive_complete()
797 self->netdev->stats.rx_length_errors++; w83977af_dma_receive_complete()
800 self->netdev->stats.rx_frame_errors++; w83977af_dma_receive_complete()
803 self->netdev->stats.rx_crc_errors++; w83977af_dma_receive_complete()
807 self->netdev->stats.rx_fifo_errors++; w83977af_dma_receive_complete()
810 self->netdev->stats.rx_fifo_errors++; w83977af_dma_receive_complete()
833 if (self->io.speed < 4000000) { w83977af_dma_receive_complete()
836 self->rx_buff.data, w83977af_dma_receive_complete()
841 self->rx_buff.data, w83977af_dma_receive_complete()
846 self->rx_buff.data += len; w83977af_dma_receive_complete()
847 self->netdev->stats.rx_packets++; w83977af_dma_receive_complete()
849 skb->dev = self->netdev; w83977af_dma_receive_complete()
862 * Function pc87108_pio_receive (self)
867 static void w83977af_pio_receive(struct w83977af_ir *self) w83977af_pio_receive() argument
872 IRDA_ASSERT(self != NULL, return;); w83977af_pio_receive()
874 iobase = self->io.fir_base; w83977af_pio_receive()
879 async_unwrap_char(self->netdev, &self->netdev->stats, &self->rx_buff, w83977af_pio_receive()
885 * Function w83977af_sir_interrupt (self, eir)
890 static __u8 w83977af_sir_interrupt(struct w83977af_ir *self, int isr) w83977af_sir_interrupt() argument
899 iobase = self->io.fir_base; w83977af_sir_interrupt()
903 actual = w83977af_pio_write(self->io.fir_base, w83977af_sir_interrupt()
904 self->tx_buff.data, w83977af_sir_interrupt()
905 self->tx_buff.len, w83977af_sir_interrupt()
906 self->io.fifo_size); w83977af_sir_interrupt()
908 self->tx_buff.data += actual; w83977af_sir_interrupt()
909 self->tx_buff.len -= actual; w83977af_sir_interrupt()
911 self->io.direction = IO_XMIT; w83977af_sir_interrupt()
914 if (self->tx_buff.len > 0) { w83977af_sir_interrupt()
922 self->netdev->stats.tx_packets++; w83977af_sir_interrupt()
925 netif_wake_queue(self->netdev); w83977af_sir_interrupt()
932 if (self->new_speed) { w83977af_sir_interrupt()
934 w83977af_change_speed(self, self->new_speed); w83977af_sir_interrupt()
935 self->new_speed = 0; w83977af_sir_interrupt()
939 self->io.direction = IO_RECV; w83977af_sir_interrupt()
945 w83977af_pio_receive(self); w83977af_sir_interrupt()
954 * Function pc87108_fir_interrupt (self, eir)
959 static __u8 w83977af_fir_interrupt(struct w83977af_ir *self, int isr) w83977af_fir_interrupt() argument
965 iobase = self->io.fir_base; w83977af_fir_interrupt()
970 if (w83977af_dma_receive_complete(self)) { w83977af_fir_interrupt()
999 if (self->io.direction == IO_XMIT) { w83977af_fir_interrupt()
1000 w83977af_dma_write(self, iobase); w83977af_fir_interrupt()
1005 w83977af_dma_receive_complete(self); w83977af_fir_interrupt()
1012 w83977af_dma_xmit_complete(self); w83977af_fir_interrupt()
1015 /* if (irda_device_txqueue_empty(self)) { */ w83977af_fir_interrupt()
1021 w83977af_dma_receive(self); w83977af_fir_interrupt()
1041 struct w83977af_ir *self; w83977af_interrupt() local
1045 self = netdev_priv(dev); w83977af_interrupt()
1047 iobase = self->io.fir_base; w83977af_interrupt()
1060 if (self->io.speed > PIO_MAX_SPEED ) w83977af_interrupt()
1061 icr = w83977af_fir_interrupt(self, isr); w83977af_interrupt()
1063 icr = w83977af_sir_interrupt(self, isr); w83977af_interrupt()
1072 * Function w83977af_is_receiving (self)
1077 static int w83977af_is_receiving(struct w83977af_ir *self) w83977af_is_receiving() argument
1083 IRDA_ASSERT(self != NULL, return FALSE;); w83977af_is_receiving()
1085 if (self->io.speed > 115200) { w83977af_is_receiving()
1086 iobase = self->io.fir_base; w83977af_is_receiving()
1097 status = (self->rx_buff.state != OUTSIDE_FRAME); w83977af_is_receiving()
1110 struct w83977af_ir *self; w83977af_net_open() local
1117 self = netdev_priv(dev); w83977af_net_open()
1119 IRDA_ASSERT(self != NULL, return 0;); w83977af_net_open()
1121 iobase = self->io.fir_base; w83977af_net_open()
1123 if (request_irq(self->io.irq, w83977af_interrupt, 0, dev->name, w83977af_net_open()
1131 if (request_dma(self->io.dma, dev->name)) { w83977af_net_open()
1132 free_irq(self->io.irq, dev); w83977af_net_open()
1141 if (self->io.speed > 115200) { w83977af_net_open()
1143 w83977af_dma_receive(self); w83977af_net_open()
1153 /* Give self a hardware name */ w83977af_net_open()
1154 sprintf(hwname, "w83977af @ 0x%03x", self->io.fir_base); w83977af_net_open()
1160 self->irlap = irlap_open(dev, &self->qos, hwname); w83977af_net_open()
1173 struct w83977af_ir *self; w83977af_net_close() local
1179 self = netdev_priv(dev); w83977af_net_close()
1181 IRDA_ASSERT(self != NULL, return 0;); w83977af_net_close()
1183 iobase = self->io.fir_base; w83977af_net_close()
1189 if (self->irlap) w83977af_net_close()
1190 irlap_close(self->irlap); w83977af_net_close()
1191 self->irlap = NULL; w83977af_net_close()
1193 disable_dma(self->io.dma); w83977af_net_close()
1202 free_irq(self->io.irq, dev); w83977af_net_close()
1203 free_dma(self->io.dma); w83977af_net_close()
1220 struct w83977af_ir *self; w83977af_net_ioctl() local
1226 self = netdev_priv(dev); w83977af_net_ioctl()
1228 IRDA_ASSERT(self != NULL, return -1;); w83977af_net_ioctl()
1232 spin_lock_irqsave(&self->lock, flags); w83977af_net_ioctl()
1240 w83977af_change_speed(self, irq->ifr_baudrate); w83977af_net_ioctl()
1247 irda_device_set_media_busy(self->netdev, TRUE); w83977af_net_ioctl()
1250 irq->ifr_receiving = w83977af_is_receiving(self); w83977af_net_ioctl()
1256 spin_unlock_irqrestore(&self->lock, flags); w83977af_net_ioctl()
|
| H A D | bfin_sir.c | 168 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_is_receiving() local
169 struct bfin_sir_port *port = self->sir_port; bfin_sir_is_receiving()
173 return self->rx_buff.state != OUTSIDE_FRAME; bfin_sir_is_receiving()
180 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_tx_chars() local
181 struct bfin_sir_port *port = self->sir_port; bfin_sir_tx_chars()
183 if (self->tx_buff.len != 0) { bfin_sir_tx_chars()
184 chr = *(self->tx_buff.data); bfin_sir_tx_chars()
186 self->tx_buff.data++; bfin_sir_tx_chars()
187 self->tx_buff.len--; bfin_sir_tx_chars()
189 self->stats.tx_packets++; bfin_sir_tx_chars()
190 self->stats.tx_bytes += self->tx_buff.data - self->tx_buff.head; bfin_sir_tx_chars()
191 if (self->newspeed) { bfin_sir_tx_chars()
192 bfin_sir_set_speed(port, self->newspeed); bfin_sir_tx_chars()
193 self->speed = self->newspeed; bfin_sir_tx_chars()
194 self->newspeed = 0; bfin_sir_tx_chars()
205 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_rx_chars() local
206 struct bfin_sir_port *port = self->sir_port; bfin_sir_rx_chars()
211 async_unwrap_char(dev, &self->stats, &self->rx_buff, ch); bfin_sir_rx_chars()
218 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_rx_int() local
219 struct bfin_sir_port *port = self->sir_port; bfin_sir_rx_int()
221 spin_lock(&self->lock); bfin_sir_rx_int()
224 spin_unlock(&self->lock); bfin_sir_rx_int()
232 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_tx_int() local
233 struct bfin_sir_port *port = self->sir_port; bfin_sir_tx_int()
235 spin_lock(&self->lock); bfin_sir_tx_int()
238 spin_unlock(&self->lock); bfin_sir_tx_int()
247 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_dma_tx_chars() local
248 struct bfin_sir_port *port = self->sir_port; bfin_sir_dma_tx_chars()
254 if (self->tx_buff.len == 0) { bfin_sir_dma_tx_chars()
255 self->stats.tx_packets++; bfin_sir_dma_tx_chars()
256 if (self->newspeed) { bfin_sir_dma_tx_chars()
257 bfin_sir_set_speed(port, self->newspeed); bfin_sir_dma_tx_chars()
258 self->speed = self->newspeed; bfin_sir_dma_tx_chars()
259 self->newspeed = 0; bfin_sir_dma_tx_chars()
267 blackfin_dcache_flush_range((unsigned long)(self->tx_buff.data), bfin_sir_dma_tx_chars()
268 (unsigned long)(self->tx_buff.data+self->tx_buff.len)); bfin_sir_dma_tx_chars()
274 (unsigned long)(self->tx_buff.data)); bfin_sir_dma_tx_chars()
275 set_dma_x_count(port->tx_dma_channel, self->tx_buff.len); bfin_sir_dma_tx_chars()
283 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_dma_tx_int() local
284 struct bfin_sir_port *port = self->sir_port; bfin_sir_dma_tx_int()
286 spin_lock(&self->lock); bfin_sir_dma_tx_int()
291 self->stats.tx_packets++; bfin_sir_dma_tx_int()
292 self->stats.tx_bytes += self->tx_buff.len; bfin_sir_dma_tx_int()
293 self->tx_buff.len = 0; bfin_sir_dma_tx_int()
294 if (self->newspeed) { bfin_sir_dma_tx_int()
295 bfin_sir_set_speed(port, self->newspeed); bfin_sir_dma_tx_int()
296 self->speed = self->newspeed; bfin_sir_dma_tx_int()
297 self->newspeed = 0; bfin_sir_dma_tx_int()
304 spin_unlock(&self->lock); bfin_sir_dma_tx_int()
311 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_dma_rx_chars() local
312 struct bfin_sir_port *port = self->sir_port; bfin_sir_dma_rx_chars()
318 async_unwrap_char(dev, &self->stats, &self->rx_buff, port->rx_dma_buf.buf[i]); bfin_sir_dma_rx_chars()
323 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_rx_dma_timeout() local
324 struct bfin_sir_port *port = self->sir_port; bfin_sir_rx_dma_timeout()
328 spin_lock_irqsave(&self->lock, flags); bfin_sir_rx_dma_timeout()
340 spin_unlock_irqrestore(&self->lock, flags); bfin_sir_rx_dma_timeout()
346 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_dma_rx_int() local
347 struct bfin_sir_port *port = self->sir_port; bfin_sir_dma_rx_int()
350 spin_lock(&self->lock); bfin_sir_dma_rx_int()
363 spin_unlock(&self->lock); bfin_sir_dma_rx_int()
457 struct bfin_sir_self *self; bfin_sir_suspend() local
464 self = netdev_priv(dev); bfin_sir_suspend()
465 if (self->open) { bfin_sir_suspend()
466 flush_work(&self->work); bfin_sir_suspend()
467 bfin_sir_shutdown(self->sir_port, dev); bfin_sir_suspend()
477 struct bfin_sir_self *self; bfin_sir_resume() local
485 self = netdev_priv(dev); bfin_sir_resume()
486 port = self->sir_port; bfin_sir_resume()
487 if (self->open) { bfin_sir_resume()
488 if (self->newspeed) { bfin_sir_resume()
489 self->speed = self->newspeed; bfin_sir_resume()
490 self->newspeed = 0; bfin_sir_resume()
506 struct bfin_sir_self *self = container_of(work, struct bfin_sir_self, work); bfin_sir_send_work() local
507 struct net_device *dev = self->sir_port->dev; bfin_sir_send_work()
508 struct bfin_sir_port *port = self->sir_port; bfin_sir_send_work()
513 turnaround_delay(dev->last_rx, self->mtt); bfin_sir_send_work()
528 /* bfin_sir_set_speed(port, self->speed); */ bfin_sir_send_work()
539 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_hard_xmit() local
544 self->mtt = irda_get_mtt(skb); bfin_sir_hard_xmit()
546 if (speed != self->speed && speed != -1) bfin_sir_hard_xmit()
547 self->newspeed = speed; bfin_sir_hard_xmit()
549 self->tx_buff.data = self->tx_buff.head; bfin_sir_hard_xmit()
551 self->tx_buff.len = 0; bfin_sir_hard_xmit()
553 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, self->tx_buff.truesize); bfin_sir_hard_xmit()
555 schedule_work(&self->work); bfin_sir_hard_xmit()
564 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_ioctl() local
565 struct bfin_sir_port *port = self->sir_port; bfin_sir_ioctl()
571 if (self->open) { bfin_sir_ioctl()
603 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_stats() local
605 return &self->stats; bfin_sir_stats()
610 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_open() local
611 struct bfin_sir_port *port = self->sir_port; bfin_sir_open()
614 self->newspeed = 0; bfin_sir_open()
615 self->speed = 9600; bfin_sir_open()
617 spin_lock_init(&self->lock); bfin_sir_open()
625 self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME); bfin_sir_open()
626 if (!self->irlap) { bfin_sir_open()
631 INIT_WORK(&self->work, bfin_sir_send_work); bfin_sir_open()
636 self->open = 1; bfin_sir_open()
644 self->open = 0; bfin_sir_open()
652 struct bfin_sir_self *self = netdev_priv(dev); bfin_sir_stop() local
654 flush_work(&self->work); bfin_sir_stop()
655 bfin_sir_shutdown(self->sir_port, dev); bfin_sir_stop()
657 if (self->rxskb) { bfin_sir_stop()
658 dev_kfree_skb(self->rxskb); bfin_sir_stop()
659 self->rxskb = NULL; bfin_sir_stop()
663 if (self->irlap) { bfin_sir_stop()
664 irlap_close(self->irlap); bfin_sir_stop()
665 self->irlap = NULL; bfin_sir_stop()
669 self->open = 0; bfin_sir_stop()
697 struct bfin_sir_self *self; bfin_sir_probe() local
719 dev = alloc_irdadev(sizeof(*self)); bfin_sir_probe()
723 self = netdev_priv(dev); bfin_sir_probe()
724 self->dev = &pdev->dev; bfin_sir_probe()
725 self->sir_port = sir_port; bfin_sir_probe()
728 err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU); bfin_sir_probe()
731 err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME); bfin_sir_probe()
738 irda_init_max_qos_capabilies(&self->qos); bfin_sir_probe()
757 self->qos.baud_rate.bits &= baudrate_mask; bfin_sir_probe()
759 self->qos.min_turn_time.bits = 1; /* 10 ms or more */ bfin_sir_probe()
761 irda_qos_bits_to_value(&self->qos); bfin_sir_probe()
766 kfree(self->tx_buff.head); bfin_sir_probe()
768 kfree(self->rx_buff.head); bfin_sir_probe()
785 struct bfin_sir_self *self; bfin_sir_remove() local
791 self = netdev_priv(dev); bfin_sir_remove()
793 kfree(self->tx_buff.head); bfin_sir_remove()
794 kfree(self->rx_buff.head); bfin_sir_remove()
|
| H A D | ali-ircc.c | 104 static int ali_ircc_close(struct ali_ircc_cb *self);
107 static int ali_ircc_is_receiving(struct ali_ircc_cb *self);
111 static void ali_ircc_change_speed(struct ali_ircc_cb *self, __u32 baud);
116 static irqreturn_t ali_ircc_sir_interrupt(struct ali_ircc_cb *self);
117 static void ali_ircc_sir_receive(struct ali_ircc_cb *self);
118 static void ali_ircc_sir_write_wakeup(struct ali_ircc_cb *self);
126 static irqreturn_t ali_ircc_fir_interrupt(struct ali_ircc_cb *self);
127 static int ali_ircc_dma_receive(struct ali_ircc_cb *self);
128 static int ali_ircc_dma_receive_complete(struct ali_ircc_cb *self);
129 static int ali_ircc_dma_xmit_complete(struct ali_ircc_cb *self);
130 static void ali_ircc_dma_xmit(struct ali_ircc_cb *self);
139 static void SetCOMInterrupts(struct ali_ircc_cb *self , unsigned char enable);
282 struct ali_ircc_cb *self; ali_ircc_open() local
296 dev = alloc_irdadev(sizeof(*self)); ali_ircc_open()
303 self = netdev_priv(dev); ali_ircc_open()
304 self->netdev = dev; ali_ircc_open()
305 spin_lock_init(&self->lock); ali_ircc_open()
307 /* Need to store self somewhere */ ali_ircc_open()
308 dev_self[i] = self; ali_ircc_open()
309 self->index = i; ali_ircc_open()
312 self->io.cfg_base = info->cfg_base; /* In ali_ircc_probe_53 assign */ ali_ircc_open()
313 self->io.fir_base = info->fir_base; /* info->sir_base = info->fir_base */ ali_ircc_open()
314 self->io.sir_base = info->sir_base; /* ALi SIR and FIR use the same address */ ali_ircc_open()
315 self->io.irq = info->irq; ali_ircc_open()
316 self->io.fir_ext = CHIP_IO_EXTENT; ali_ircc_open()
317 self->io.dma = info->dma; ali_ircc_open()
318 self->io.fifo_size = 16; /* SIR: 16, FIR: 32 Benjamin 2000/11/1 */ ali_ircc_open()
321 if (!request_region(self->io.fir_base, self->io.fir_ext, ali_ircc_open()
324 __func__, self->io.fir_base); ali_ircc_open()
330 irda_init_max_qos_capabilies(&self->qos); ali_ircc_open()
333 self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600| ali_ircc_open()
336 self->qos.min_turn_time.bits = qos_mtt_bits; ali_ircc_open()
338 irda_qos_bits_to_value(&self->qos); ali_ircc_open()
341 self->rx_buff.truesize = 14384; ali_ircc_open()
342 self->tx_buff.truesize = 14384; ali_ircc_open()
345 self->rx_buff.head = ali_ircc_open()
346 dma_zalloc_coherent(NULL, self->rx_buff.truesize, ali_ircc_open()
347 &self->rx_buff_dma, GFP_KERNEL); ali_ircc_open()
348 if (self->rx_buff.head == NULL) { ali_ircc_open()
353 self->tx_buff.head = ali_ircc_open()
354 dma_zalloc_coherent(NULL, self->tx_buff.truesize, ali_ircc_open()
355 &self->tx_buff_dma, GFP_KERNEL); ali_ircc_open()
356 if (self->tx_buff.head == NULL) { ali_ircc_open()
361 self->rx_buff.in_frame = FALSE; ali_ircc_open()
362 self->rx_buff.state = OUTSIDE_FRAME; ali_ircc_open()
363 self->tx_buff.data = self->tx_buff.head; ali_ircc_open()
364 self->rx_buff.data = self->rx_buff.head; ali_ircc_open()
367 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; ali_ircc_open()
368 self->tx_fifo.tail = self->tx_buff.head; ali_ircc_open()
387 self->io.dongle_id = dongle_id; ali_ircc_open()
393 dma_free_coherent(NULL, self->tx_buff.truesize, ali_ircc_open()
394 self->tx_buff.head, self->tx_buff_dma); ali_ircc_open()
396 dma_free_coherent(NULL, self->rx_buff.truesize, ali_ircc_open()
397 self->rx_buff.head, self->rx_buff_dma); ali_ircc_open()
399 release_region(self->io.fir_base, self->io.fir_ext); ali_ircc_open()
408 * Function ali_ircc_close (self)
413 static int __exit ali_ircc_close(struct ali_ircc_cb *self) ali_ircc_close() argument
417 IRDA_ASSERT(self != NULL, return -1;); ali_ircc_close()
419 iobase = self->io.fir_base; ali_ircc_close()
422 unregister_netdev(self->netdev); ali_ircc_close()
425 pr_debug("%s(), Releasing Region %03x\n", __func__, self->io.fir_base); ali_ircc_close()
426 release_region(self->io.fir_base, self->io.fir_ext); ali_ircc_close()
428 if (self->tx_buff.head) ali_ircc_close()
429 dma_free_coherent(NULL, self->tx_buff.truesize, ali_ircc_close()
430 self->tx_buff.head, self->tx_buff_dma); ali_ircc_close()
432 if (self->rx_buff.head) ali_ircc_close()
433 dma_free_coherent(NULL, self->rx_buff.truesize, ali_ircc_close()
434 self->rx_buff.head, self->rx_buff_dma); ali_ircc_close()
436 dev_self[self->index] = NULL; ali_ircc_close()
437 free_netdev(self->netdev); ali_ircc_close()
658 struct ali_ircc_cb *self; ali_ircc_interrupt() local
662 self = netdev_priv(dev); ali_ircc_interrupt()
664 spin_lock(&self->lock); ali_ircc_interrupt()
667 if (self->io.speed > 115200) ali_ircc_interrupt()
668 ret = ali_ircc_fir_interrupt(self); ali_ircc_interrupt()
670 ret = ali_ircc_sir_interrupt(self); ali_ircc_interrupt()
672 spin_unlock(&self->lock); ali_ircc_interrupt()
677 * Function ali_ircc_fir_interrupt(irq, struct ali_ircc_cb *self)
682 static irqreturn_t ali_ircc_fir_interrupt(struct ali_ircc_cb *self) ali_ircc_fir_interrupt() argument
688 iobase = self->io.fir_base; ali_ircc_fir_interrupt()
691 self->InterruptID = inb(iobase+FIR_IIR); ali_ircc_fir_interrupt()
692 self->BusStatus = inb(iobase+FIR_BSR); ali_ircc_fir_interrupt()
694 OldMessageCount = (self->LineStatus + 1) & 0x07; ali_ircc_fir_interrupt()
695 self->LineStatus = inb(iobase+FIR_LSR); ali_ircc_fir_interrupt()
696 //self->ier = inb(iobase+FIR_IER); 2000/12/1 04:32PM ali_ircc_fir_interrupt()
697 eir = self->InterruptID & self->ier; /* Mask out the interesting ones */ ali_ircc_fir_interrupt()
699 pr_debug("%s(), self->InterruptID = %x\n", __func__, self->InterruptID); ali_ircc_fir_interrupt()
700 pr_debug("%s(), self->LineStatus = %x\n", __func__, self->LineStatus); ali_ircc_fir_interrupt()
701 pr_debug("%s(), self->ier = %x\n", __func__, self->ier); ali_ircc_fir_interrupt()
705 SetCOMInterrupts(self, FALSE); ali_ircc_fir_interrupt()
711 if (self->io.direction == IO_XMIT) /* TX */ ali_ircc_fir_interrupt()
716 if(ali_ircc_dma_xmit_complete(self)) ali_ircc_fir_interrupt()
718 if (irda_device_txqueue_empty(self->netdev)) ali_ircc_fir_interrupt()
721 ali_ircc_dma_receive(self); ali_ircc_fir_interrupt()
722 self->ier = IER_EOM; ali_ircc_fir_interrupt()
727 self->ier = IER_EOM; ali_ircc_fir_interrupt()
736 if(OldMessageCount > ((self->LineStatus+1) & 0x07)) ali_ircc_fir_interrupt()
738 self->rcvFramesOverflow = TRUE; ali_ircc_fir_interrupt()
739 pr_debug("%s(), ******* self->rcvFramesOverflow = TRUE ********\n", ali_ircc_fir_interrupt()
743 if (ali_ircc_dma_receive_complete(self)) ali_ircc_fir_interrupt()
748 self->ier = IER_EOM; ali_ircc_fir_interrupt()
755 self->ier = IER_EOM | IER_TIMER; ali_ircc_fir_interrupt()
763 if(OldMessageCount > ((self->LineStatus+1) & 0x07)) ali_ircc_fir_interrupt()
765 self->rcvFramesOverflow = TRUE; ali_ircc_fir_interrupt()
766 pr_debug("%s(), ******* self->rcvFramesOverflow = TRUE *******\n", ali_ircc_fir_interrupt()
775 if (self->io.direction == IO_XMIT) ali_ircc_fir_interrupt()
777 ali_ircc_dma_xmit(self); ali_ircc_fir_interrupt()
780 self->ier = IER_EOM; ali_ircc_fir_interrupt()
785 if(ali_ircc_dma_receive_complete(self)) ali_ircc_fir_interrupt()
787 self->ier = IER_EOM; ali_ircc_fir_interrupt()
791 self->ier = IER_EOM | IER_TIMER; ali_ircc_fir_interrupt()
797 SetCOMInterrupts(self, TRUE); ali_ircc_fir_interrupt()
803 * Function ali_ircc_sir_interrupt (irq, self, eir)
808 static irqreturn_t ali_ircc_sir_interrupt(struct ali_ircc_cb *self) ali_ircc_sir_interrupt() argument
814 iobase = self->io.sir_base; ali_ircc_sir_interrupt()
831 ali_ircc_sir_receive(self); ali_ircc_sir_interrupt()
837 ali_ircc_sir_write_wakeup(self); ali_ircc_sir_interrupt()
854 * Function ali_ircc_sir_receive (self)
859 static void ali_ircc_sir_receive(struct ali_ircc_cb *self) ali_ircc_sir_receive() argument
864 IRDA_ASSERT(self != NULL, return;); ali_ircc_sir_receive()
866 iobase = self->io.sir_base; ali_ircc_sir_receive()
873 async_unwrap_char(self->netdev, &self->netdev->stats, &self->rx_buff, ali_ircc_sir_receive()
892 static void ali_ircc_sir_write_wakeup(struct ali_ircc_cb *self) ali_ircc_sir_write_wakeup() argument
897 IRDA_ASSERT(self != NULL, return;); ali_ircc_sir_write_wakeup()
900 iobase = self->io.sir_base; ali_ircc_sir_write_wakeup()
903 if (self->tx_buff.len > 0) ali_ircc_sir_write_wakeup()
906 actual = ali_ircc_sir_write(iobase, self->io.fifo_size, ali_ircc_sir_write_wakeup()
907 self->tx_buff.data, self->tx_buff.len); ali_ircc_sir_write_wakeup()
908 self->tx_buff.data += actual; ali_ircc_sir_write_wakeup()
909 self->tx_buff.len -= actual; ali_ircc_sir_write_wakeup()
913 if (self->new_speed) ali_ircc_sir_write_wakeup()
919 pr_debug("%s(), Changing speed! self->new_speed = %d\n", ali_ircc_sir_write_wakeup()
920 __func__, self->new_speed); ali_ircc_sir_write_wakeup()
921 ali_ircc_change_speed(self, self->new_speed); ali_ircc_sir_write_wakeup()
922 self->new_speed = 0; ali_ircc_sir_write_wakeup()
925 if (self->io.speed > 115200) ali_ircc_sir_write_wakeup()
930 self->ier = IER_EOM; ali_ircc_sir_write_wakeup()
931 // SetCOMInterrupts(self, TRUE); ali_ircc_sir_write_wakeup()
937 netif_wake_queue(self->netdev); ali_ircc_sir_write_wakeup()
940 self->netdev->stats.tx_packets++; ali_ircc_sir_write_wakeup()
948 static void ali_ircc_change_speed(struct ali_ircc_cb *self, __u32 baud) ali_ircc_change_speed() argument
950 struct net_device *dev = self->netdev; ali_ircc_change_speed()
959 iobase = self->io.fir_base; ali_ircc_change_speed()
961 SetCOMInterrupts(self, FALSE); // 2000/11/24 11:43AM ali_ircc_change_speed()
968 ali_ircc_fir_change_speed(self, baud); ali_ircc_change_speed()
974 self->ier = IER_EOM; // benjamin 2000/11/20 07:24PM ali_ircc_change_speed()
977 ali_ircc_dma_receive(self); // benajmin 2000/11/8 07:46PM not complete ali_ircc_change_speed()
982 ali_ircc_sir_change_speed(self, baud); ali_ircc_change_speed()
989 SetCOMInterrupts(self, TRUE); // 2000/11/24 11:43AM ali_ircc_change_speed()
991 netif_wake_queue(self->netdev); ali_ircc_change_speed()
999 struct ali_ircc_cb *self = priv; ali_ircc_fir_change_speed() local
1003 IRDA_ASSERT(self != NULL, return;); ali_ircc_fir_change_speed()
1005 dev = self->netdev; ali_ircc_fir_change_speed()
1006 iobase = self->io.fir_base; ali_ircc_fir_change_speed()
1008 pr_debug("%s(), self->io.speed = %d, change to speed = %d\n", ali_ircc_fir_change_speed()
1009 __func__, self->io.speed, baud); ali_ircc_fir_change_speed()
1012 if(self->io.speed <=115200) ali_ircc_fir_change_speed()
1018 self->io.speed = baud; ali_ircc_fir_change_speed()
1021 ali_ircc_change_dongle_speed(self, baud); ali_ircc_fir_change_speed()
1026 * Function ali_sir_change_speed (self, speed)
1033 struct ali_ircc_cb *self = priv; ali_ircc_sir_change_speed() local
1043 IRDA_ASSERT(self != NULL, return;); ali_ircc_sir_change_speed()
1045 iobase = self->io.sir_base; ali_ircc_sir_change_speed()
1048 if(self->io.speed >115200) ali_ircc_sir_change_speed()
1051 ali_ircc_change_dongle_speed(self, speed); ali_ircc_sir_change_speed()
1062 self->io.speed = speed; ali_ircc_sir_change_speed()
1064 spin_lock_irqsave(&self->lock, flags); ali_ircc_sir_change_speed()
1075 if (self->io.speed < 38400) ali_ircc_sir_change_speed()
1093 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_sir_change_speed()
1100 struct ali_ircc_cb *self = priv; ali_ircc_change_dongle_speed() local
1105 iobase = self->io.fir_base; /* or iobase = self->io.sir_base; */ ali_ircc_change_dongle_speed()
1106 dongle_id = self->io.dongle_id; ali_ircc_change_dongle_speed()
1313 struct ali_ircc_cb *self; ali_ircc_net_open() local
1320 self = netdev_priv(dev); ali_ircc_net_open()
1322 IRDA_ASSERT(self != NULL, return 0;); ali_ircc_net_open()
1324 iobase = self->io.fir_base; ali_ircc_net_open()
1327 if (request_irq(self->io.irq, ali_ircc_interrupt, 0, dev->name, dev)) ali_ircc_net_open()
1330 ALI_IRCC_DRIVER_NAME, self->io.irq); ali_ircc_net_open()
1338 if (request_dma(self->io.dma, dev->name)) { ali_ircc_net_open()
1340 ALI_IRCC_DRIVER_NAME, self->io.dma); ali_ircc_net_open()
1341 free_irq(self->io.irq, dev); ali_ircc_net_open()
1351 /* Give self a hardware name */ ali_ircc_net_open()
1352 sprintf(hwname, "ALI-FIR @ 0x%03x", self->io.fir_base); ali_ircc_net_open()
1358 self->irlap = irlap_open(dev, &self->qos, hwname); ali_ircc_net_open()
1373 struct ali_ircc_cb *self; ali_ircc_net_close() local
1379 self = netdev_priv(dev); ali_ircc_net_close()
1380 IRDA_ASSERT(self != NULL, return 0;); ali_ircc_net_close()
1386 if (self->irlap) ali_ircc_net_close()
1387 irlap_close(self->irlap); ali_ircc_net_close()
1388 self->irlap = NULL; ali_ircc_net_close()
1390 disable_dma(self->io.dma); ali_ircc_net_close()
1393 SetCOMInterrupts(self, FALSE); ali_ircc_net_close()
1395 free_irq(self->io.irq, dev); ali_ircc_net_close()
1396 free_dma(self->io.dma); ali_ircc_net_close()
1411 struct ali_ircc_cb *self; ali_ircc_fir_hard_xmit() local
1418 self = netdev_priv(dev); ali_ircc_fir_hard_xmit()
1419 iobase = self->io.fir_base; ali_ircc_fir_hard_xmit()
1424 spin_lock_irqsave(&self->lock, flags); ali_ircc_fir_hard_xmit()
1432 if ((speed != self->io.speed) && (speed != -1)) { ali_ircc_fir_hard_xmit()
1435 ali_ircc_change_speed(self, speed); ali_ircc_fir_hard_xmit()
1437 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_fir_hard_xmit()
1441 self->new_speed = speed; ali_ircc_fir_hard_xmit()
1445 self->tx_fifo.queue[self->tx_fifo.free].start = self->tx_fifo.tail; ali_ircc_fir_hard_xmit()
1446 self->tx_fifo.queue[self->tx_fifo.free].len = skb->len; ali_ircc_fir_hard_xmit()
1447 self->tx_fifo.tail += skb->len; ali_ircc_fir_hard_xmit()
1451 skb_copy_from_linear_data(skb, self->tx_fifo.queue[self->tx_fifo.free].start, ali_ircc_fir_hard_xmit()
1453 self->tx_fifo.len++; ali_ircc_fir_hard_xmit()
1454 self->tx_fifo.free++; ali_ircc_fir_hard_xmit()
1457 if (self->tx_fifo.len == 1) ali_ircc_fir_hard_xmit()
1465 diff = ktime_us_delta(ktime_get(), self->stamp); ali_ircc_fir_hard_xmit()
1466 /* self->stamp is set from ali_ircc_dma_receive_complete() */ ali_ircc_fir_hard_xmit()
1511 self->io.direction = IO_XMIT; ali_ircc_fir_hard_xmit()
1514 self->ier = IER_TIMER; ali_ircc_fir_hard_xmit()
1515 SetCOMInterrupts(self, TRUE); ali_ircc_fir_hard_xmit()
1526 self->ier = IER_EOM; ali_ircc_fir_hard_xmit()
1527 SetCOMInterrupts(self, TRUE); ali_ircc_fir_hard_xmit()
1530 ali_ircc_dma_xmit(self); ali_ircc_fir_hard_xmit()
1531 } // if (self->tx_fifo.len == 1) ali_ircc_fir_hard_xmit()
1536 if (self->tx_fifo.free < MAX_TX_WINDOW) ali_ircc_fir_hard_xmit()
1537 netif_wake_queue(self->netdev); ali_ircc_fir_hard_xmit()
1543 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_fir_hard_xmit()
1550 static void ali_ircc_dma_xmit(struct ali_ircc_cb *self) ali_ircc_dma_xmit() argument
1557 iobase = self->io.fir_base; ali_ircc_dma_xmit()
1561 if(self->tx_fifo.queue[self->tx_fifo.ptr].len < TX_FIFO_Threshold) ali_ircc_dma_xmit()
1562 FIFO_OPTI = self->tx_fifo.queue[self->tx_fifo.ptr].len-1; ali_ircc_dma_xmit()
1570 self->io.direction = IO_XMIT; ali_ircc_dma_xmit()
1572 irda_setup_dma(self->io.dma, ali_ircc_dma_xmit()
1573 ((u8 *)self->tx_fifo.queue[self->tx_fifo.ptr].start - ali_ircc_dma_xmit()
1574 self->tx_buff.head) + self->tx_buff_dma, ali_ircc_dma_xmit()
1575 self->tx_fifo.queue[self->tx_fifo.ptr].len, ali_ircc_dma_xmit()
1583 if (self->fifo_opti_buf!=FIFO_OPTI) ali_ircc_dma_xmit()
1587 self->fifo_opti_buf=FIFO_OPTI; ali_ircc_dma_xmit()
1595 Hi = (self->tx_fifo.queue[self->tx_fifo.ptr].len >> 8) & 0x0f; ali_ircc_dma_xmit()
1596 Lo = self->tx_fifo.queue[self->tx_fifo.ptr].len & 0xff; ali_ircc_dma_xmit()
1619 static int ali_ircc_dma_xmit_complete(struct ali_ircc_cb *self) ali_ircc_dma_xmit_complete() argument
1625 iobase = self->io.fir_base; ali_ircc_dma_xmit_complete()
1638 self->netdev->stats.tx_errors++; ali_ircc_dma_xmit_complete()
1639 self->netdev->stats.tx_fifo_errors++; ali_ircc_dma_xmit_complete()
1643 self->netdev->stats.tx_packets++; ali_ircc_dma_xmit_complete()
1647 if (self->new_speed) ali_ircc_dma_xmit_complete()
1649 ali_ircc_change_speed(self, self->new_speed); ali_ircc_dma_xmit_complete()
1650 self->new_speed = 0; ali_ircc_dma_xmit_complete()
1654 self->tx_fifo.ptr++; ali_ircc_dma_xmit_complete()
1655 self->tx_fifo.len--; ali_ircc_dma_xmit_complete()
1658 if (self->tx_fifo.len) ali_ircc_dma_xmit_complete()
1660 ali_ircc_dma_xmit(self); ali_ircc_dma_xmit_complete()
1667 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; ali_ircc_dma_xmit_complete()
1668 self->tx_fifo.tail = self->tx_buff.head; ali_ircc_dma_xmit_complete()
1672 if (self->tx_fifo.free < MAX_TX_WINDOW) { ali_ircc_dma_xmit_complete()
1675 netif_wake_queue(self->netdev); ali_ircc_dma_xmit_complete()
1684 * Function ali_ircc_dma_receive (self)
1690 static int ali_ircc_dma_receive(struct ali_ircc_cb *self) ali_ircc_dma_receive() argument
1695 iobase = self->io.fir_base; ali_ircc_dma_receive()
1698 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; ali_ircc_dma_receive()
1699 self->tx_fifo.tail = self->tx_buff.head; ali_ircc_dma_receive()
1709 self->rcvFramesOverflow = FALSE; ali_ircc_dma_receive()
1711 self->LineStatus = inb(iobase+FIR_LSR) ; ali_ircc_dma_receive()
1714 self->io.direction = IO_RECV; ali_ircc_dma_receive()
1715 self->rx_buff.data = self->rx_buff.head; ali_ircc_dma_receive()
1721 self->st_fifo.len = self->st_fifo.pending_bytes = 0; ali_ircc_dma_receive()
1722 self->st_fifo.tail = self->st_fifo.head = 0; ali_ircc_dma_receive()
1724 irda_setup_dma(self->io.dma, self->rx_buff_dma, self->rx_buff.truesize, ali_ircc_dma_receive()
1747 static int ali_ircc_dma_receive_complete(struct ali_ircc_cb *self) ali_ircc_dma_receive_complete() argument
1754 st_fifo = &self->st_fifo; ali_ircc_dma_receive_complete()
1755 iobase = self->io.fir_base; ali_ircc_dma_receive_complete()
1799 if ((status & 0xd8) || self->rcvFramesOverflow || (len==0)) ali_ircc_dma_receive_complete()
1805 self->netdev->stats.rx_errors++; ali_ircc_dma_receive_complete()
1807 self->rx_buff.data += len; ali_ircc_dma_receive_complete()
1811 self->netdev->stats.rx_frame_errors++; ali_ircc_dma_receive_complete()
1817 self->netdev->stats.rx_frame_errors++; ali_ircc_dma_receive_complete()
1824 self->netdev->stats.rx_crc_errors++; ali_ircc_dma_receive_complete()
1829 if(self->rcvFramesOverflow) ali_ircc_dma_receive_complete()
1831 self->netdev->stats.rx_frame_errors++; ali_ircc_dma_receive_complete()
1837 self->netdev->stats.rx_frame_errors++; ali_ircc_dma_receive_complete()
1882 self->stamp = ktime_get(); ali_ircc_dma_receive_complete()
1887 self->netdev->stats.rx_dropped++; ali_ircc_dma_receive_complete()
1897 skb_copy_to_linear_data(skb, self->rx_buff.data, len); ali_ircc_dma_receive_complete()
1900 self->rx_buff.data += len; ali_ircc_dma_receive_complete()
1901 self->netdev->stats.rx_bytes += len; ali_ircc_dma_receive_complete()
1902 self->netdev->stats.rx_packets++; ali_ircc_dma_receive_complete()
1904 skb->dev = self->netdev; ali_ircc_dma_receive_complete()
1927 struct ali_ircc_cb *self; ali_ircc_sir_hard_xmit() local
1935 self = netdev_priv(dev); ali_ircc_sir_hard_xmit()
1936 IRDA_ASSERT(self != NULL, return NETDEV_TX_OK;); ali_ircc_sir_hard_xmit()
1938 iobase = self->io.sir_base; ali_ircc_sir_hard_xmit()
1943 spin_lock_irqsave(&self->lock, flags); ali_ircc_sir_hard_xmit()
1951 if ((speed != self->io.speed) && (speed != -1)) { ali_ircc_sir_hard_xmit()
1954 ali_ircc_change_speed(self, speed); ali_ircc_sir_hard_xmit()
1956 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_sir_hard_xmit()
1960 self->new_speed = speed; ali_ircc_sir_hard_xmit()
1964 self->tx_buff.data = self->tx_buff.head; ali_ircc_sir_hard_xmit()
1967 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, ali_ircc_sir_hard_xmit()
1968 self->tx_buff.truesize); ali_ircc_sir_hard_xmit()
1970 self->netdev->stats.tx_bytes += self->tx_buff.len; ali_ircc_sir_hard_xmit()
1976 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_sir_hard_xmit()
1994 struct ali_ircc_cb *self; ali_ircc_net_ioctl() local
2001 self = netdev_priv(dev); ali_ircc_net_ioctl()
2003 IRDA_ASSERT(self != NULL, return -1;); ali_ircc_net_ioctl()
2018 spin_lock_irqsave(&self->lock, flags); ali_ircc_net_ioctl()
2019 ali_ircc_change_speed(self, irq->ifr_baudrate); ali_ircc_net_ioctl()
2020 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_net_ioctl()
2026 irda_device_set_media_busy(self->netdev, TRUE); ali_ircc_net_ioctl()
2031 irq->ifr_receiving = ali_ircc_is_receiving(self); ali_ircc_net_ioctl()
2042 * Function ali_ircc_is_receiving (self)
2047 static int ali_ircc_is_receiving(struct ali_ircc_cb *self) ali_ircc_is_receiving() argument
2054 IRDA_ASSERT(self != NULL, return FALSE;); ali_ircc_is_receiving()
2056 spin_lock_irqsave(&self->lock, flags); ali_ircc_is_receiving()
2058 if (self->io.speed > 115200) ali_ircc_is_receiving()
2060 iobase = self->io.fir_base; ali_ircc_is_receiving()
2074 status = (self->rx_buff.state != OUTSIDE_FRAME); ali_ircc_is_receiving()
2077 spin_unlock_irqrestore(&self->lock, flags); ali_ircc_is_receiving()
2085 struct ali_ircc_cb *self = platform_get_drvdata(dev); ali_ircc_suspend() local
2089 if (self->io.suspended) ali_ircc_suspend()
2092 ali_ircc_net_close(self->netdev); ali_ircc_suspend()
2094 self->io.suspended = 1; ali_ircc_suspend()
2101 struct ali_ircc_cb *self = platform_get_drvdata(dev); ali_ircc_resume() local
2103 if (!self->io.suspended) ali_ircc_resume()
2106 ali_ircc_net_open(self->netdev); ali_ircc_resume()
2110 self->io.suspended = 0; ali_ircc_resume()
2117 static void SetCOMInterrupts(struct ali_ircc_cb *self , unsigned char enable) SetCOMInterrupts()
2122 int iobase = self->io.fir_base; /* or sir_base */ SetCOMInterrupts()
2129 if (self->io.direction == IO_XMIT) SetCOMInterrupts()
2131 if (self->io.speed > 115200) /* FIR, MIR */ SetCOMInterrupts()
2133 newMask = self->ier; SetCOMInterrupts()
2141 if (self->io.speed > 115200) /* FIR, MIR */ SetCOMInterrupts()
2143 newMask = self->ier; SetCOMInterrupts()
2158 if (self->io.speed > 115200) SetCOMInterrupts()
|
| H A D | sh_sir.c | 127 static void sh_sir_write(struct sh_sir_self *self, u32 offset, u16 data) sh_sir_write() argument
129 iowrite16(data, self->membase + offset); sh_sir_write()
132 static u16 sh_sir_read(struct sh_sir_self *self, u32 offset) sh_sir_read() argument
134 return ioread16(self->membase + offset); sh_sir_read()
137 static void sh_sir_update_bits(struct sh_sir_self *self, u32 offset, sh_sir_update_bits() argument
142 old = sh_sir_read(self, offset); sh_sir_update_bits()
145 sh_sir_write(self, offset, new); sh_sir_update_bits()
155 static void sh_sir_crc_reset(struct sh_sir_self *self) sh_sir_crc_reset() argument
157 sh_sir_write(self, IRIF_CRC0, CRC_RST); sh_sir_crc_reset()
160 static void sh_sir_crc_add(struct sh_sir_self *self, u8 data) sh_sir_crc_add() argument
162 sh_sir_write(self, IRIF_CRC1, (u16)data); sh_sir_crc_add()
165 static u16 sh_sir_crc_cnt(struct sh_sir_self *self) sh_sir_crc_cnt() argument
167 return CRC_CT_MASK & sh_sir_read(self, IRIF_CRC0); sh_sir_crc_cnt()
170 static u16 sh_sir_crc_out(struct sh_sir_self *self) sh_sir_crc_out() argument
172 return sh_sir_read(self, IRIF_CRC4); sh_sir_crc_out()
175 static int sh_sir_crc_init(struct sh_sir_self *self) sh_sir_crc_init() argument
177 struct device *dev = &self->ndev->dev; sh_sir_crc_init()
181 sh_sir_crc_reset(self); sh_sir_crc_init()
183 sh_sir_crc_add(self, 0xCC); sh_sir_crc_init()
184 sh_sir_crc_add(self, 0xF5); sh_sir_crc_init()
185 sh_sir_crc_add(self, 0xF1); sh_sir_crc_init()
186 sh_sir_crc_add(self, 0xA7); sh_sir_crc_init()
188 val = sh_sir_crc_cnt(self); sh_sir_crc_init()
194 val = sh_sir_crc_out(self); sh_sir_crc_init()
204 sh_sir_crc_reset(self); sh_sir_crc_init()
247 static int sh_sir_set_baudrate(struct sh_sir_self *self, u32 baudrate) sh_sir_set_baudrate() argument
250 struct device *dev = &self->ndev->dev; sh_sir_set_baudrate()
328 sh_sir_write(self, IRIF_SIR0, IRTPW | IRERRC); sh_sir_set_baudrate()
329 sh_sir_write(self, IRIF_SIR1, irbca); sh_sir_set_baudrate()
330 sh_sir_write(self, IRIF_SIR2, irbc); sh_sir_set_baudrate()
368 sh_sir_write(self, IRIF_UART6, uabca); sh_sir_set_baudrate()
369 sh_sir_write(self, IRIF_UART7, uabc); sh_sir_set_baudrate()
395 static void sh_sir_remove_iobuf(struct sh_sir_self *self) sh_sir_remove_iobuf() argument
397 kfree(self->rx_buff.head); sh_sir_remove_iobuf()
398 kfree(self->tx_buff.head); sh_sir_remove_iobuf()
400 self->rx_buff.head = NULL; sh_sir_remove_iobuf()
401 self->tx_buff.head = NULL; sh_sir_remove_iobuf()
404 static int sh_sir_init_iobuf(struct sh_sir_self *self, int rxsize, int txsize) sh_sir_init_iobuf() argument
408 if (self->rx_buff.head || sh_sir_init_iobuf()
409 self->tx_buff.head) { sh_sir_init_iobuf()
410 dev_err(&self->ndev->dev, "iobuff has already existed."); sh_sir_init_iobuf()
414 err = __sh_sir_init_iobuf(&self->rx_buff, rxsize); sh_sir_init_iobuf()
418 err = __sh_sir_init_iobuf(&self->tx_buff, txsize); sh_sir_init_iobuf()
422 sh_sir_remove_iobuf(self); sh_sir_init_iobuf()
434 static void sh_sir_clear_all_err(struct sh_sir_self *self) sh_sir_clear_all_err() argument
437 sh_sir_update_bits(self, IRIF_SIR0, IRERRC, IRERRC); sh_sir_clear_all_err()
440 sh_sir_write(self, IRIF_SIR_FLG, 0xffff); sh_sir_clear_all_err()
443 sh_sir_write(self, IRIF_UART_STS2, 0); sh_sir_clear_all_err()
446 static void sh_sir_set_phase(struct sh_sir_self *self, int phase) sh_sir_set_phase() argument
468 sh_sir_write(self, IRIF_UART5, uart5); sh_sir_set_phase()
469 sh_sir_write(self, IRIF_UART0, uart0); sh_sir_set_phase()
472 static int sh_sir_is_which_phase(struct sh_sir_self *self) sh_sir_is_which_phase() argument
474 u16 val = sh_sir_read(self, IRIF_UART5); sh_sir_is_which_phase()
488 static void sh_sir_tx(struct sh_sir_self *self, int phase) sh_sir_tx() argument
492 if (0 >= self->tx_buff.len) { sh_sir_tx()
493 sh_sir_set_phase(self, TX_COMP_PHASE); sh_sir_tx()
495 sh_sir_write(self, IRIF_UART3, self->tx_buff.data[0]); sh_sir_tx()
496 self->tx_buff.len--; sh_sir_tx()
497 self->tx_buff.data++; sh_sir_tx()
501 sh_sir_set_phase(self, RX_PHASE); sh_sir_tx()
502 netif_wake_queue(self->ndev); sh_sir_tx()
505 dev_err(&self->ndev->dev, "should not happen\n"); sh_sir_tx()
510 static int sh_sir_read_data(struct sh_sir_self *self) sh_sir_read_data() argument
516 val = sh_sir_read(self, IRIF_UART1); sh_sir_read_data()
523 return (int)sh_sir_read(self, IRIF_UART4); sh_sir_read_data()
529 dev_err(&self->ndev->dev, "UART1 %04x : STATUS %04x\n", sh_sir_read_data()
530 val, sh_sir_read(self, IRIF_UART_STS2)); sh_sir_read_data()
533 sh_sir_read(self, IRIF_UART4); sh_sir_read_data()
538 static void sh_sir_rx(struct sh_sir_self *self) sh_sir_rx() argument
544 data = sh_sir_read_data(self); sh_sir_rx()
548 async_unwrap_char(self->ndev, &self->ndev->stats, sh_sir_rx()
549 &self->rx_buff, (u8)data); sh_sir_rx()
550 self->ndev->last_rx = jiffies; sh_sir_rx()
552 if (EOFD & sh_sir_read(self, IRIF_SIR_FRM)) sh_sir_rx()
561 struct sh_sir_self *self = dev_id; sh_sir_irq() local
562 struct device *dev = &self->ndev->dev; sh_sir_irq()
563 int phase = sh_sir_is_which_phase(self); sh_sir_irq()
568 sh_sir_tx(self, phase); sh_sir_irq()
571 if (sh_sir_read(self, IRIF_SIR3)) sh_sir_irq()
574 sh_sir_rx(self); sh_sir_irq()
575 sh_sir_clear_all_err(self); sh_sir_irq()
593 struct sh_sir_self *self = netdev_priv(ndev); sh_sir_hard_xmit() local
604 self->tx_buff.data = self->tx_buff.head; sh_sir_hard_xmit()
605 self->tx_buff.len = 0; sh_sir_hard_xmit()
607 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, sh_sir_hard_xmit()
608 self->tx_buff.truesize); sh_sir_hard_xmit()
610 sh_sir_set_phase(self, TX_PHASE); sh_sir_hard_xmit()
629 struct sh_sir_self *self = netdev_priv(ndev); sh_sir_stats() local
631 return &self->ndev->stats; sh_sir_stats()
636 struct sh_sir_self *self = netdev_priv(ndev); sh_sir_open() local
639 clk_enable(self->clk); sh_sir_open()
640 err = sh_sir_crc_init(self); sh_sir_open()
644 sh_sir_set_baudrate(self, 9600); sh_sir_open()
646 self->irlap = irlap_open(ndev, &self->qos, DRIVER_NAME); sh_sir_open()
647 if (!self->irlap) { sh_sir_open()
655 sh_sir_update_bits(self, IRIF_SIR_FRM, FRP, FRP); sh_sir_open()
656 sh_sir_read(self, IRIF_UART1); /* flag clear */ sh_sir_open()
657 sh_sir_read(self, IRIF_UART4); /* flag clear */ sh_sir_open()
658 sh_sir_set_phase(self, RX_PHASE); sh_sir_open()
662 dev_info(&self->ndev->dev, "opened\n"); sh_sir_open()
667 clk_disable(self->clk); sh_sir_open()
674 struct sh_sir_self *self = netdev_priv(ndev); sh_sir_stop() local
677 if (self->irlap) { sh_sir_stop()
678 irlap_close(self->irlap); sh_sir_stop()
679 self->irlap = NULL; sh_sir_stop()
707 struct sh_sir_self *self; sh_sir_probe() local
720 ndev = alloc_irdadev(sizeof(*self)); sh_sir_probe()
724 self = netdev_priv(ndev); sh_sir_probe()
725 self->membase = ioremap_nocache(res->start, resource_size(res)); sh_sir_probe()
726 if (!self->membase) { sh_sir_probe()
732 err = sh_sir_init_iobuf(self, IRDA_SKB_MAX_MTU, IRDA_SIR_MAX_FRAME); sh_sir_probe()
737 self->clk = clk_get(&pdev->dev, clk_name); sh_sir_probe()
738 if (IS_ERR(self->clk)) { sh_sir_probe()
744 irda_init_max_qos_capabilies(&self->qos); sh_sir_probe()
749 self->ndev = ndev; sh_sir_probe()
750 self->qos.baud_rate.bits &= IR_9600; /* FIXME */ sh_sir_probe()
751 self->qos.min_turn_time.bits = 1; /* 10 ms or more */ sh_sir_probe()
753 irda_qos_bits_to_value(&self->qos); sh_sir_probe()
760 err = devm_request_irq(&pdev->dev, irq, sh_sir_irq, 0, "sh_sir", self); sh_sir_probe()
771 clk_put(self->clk); sh_sir_probe()
773 sh_sir_remove_iobuf(self); sh_sir_probe()
775 iounmap(self->membase); sh_sir_probe()
785 struct sh_sir_self *self = netdev_priv(ndev); sh_sir_remove() local
787 if (!self) sh_sir_remove()
791 clk_put(self->clk); sh_sir_remove()
792 sh_sir_remove_iobuf(self); sh_sir_remove()
793 iounmap(self->membase); sh_sir_remove()
|
| H A D | irda-usb.c | 109 static void irda_usb_init_qos(struct irda_usb_cb *self) ;
112 static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self);
115 static int irda_usb_open(struct irda_usb_cb *self);
116 static void irda_usb_close(struct irda_usb_cb *self);
134 * Function irda_usb_build_header(self, skb, header)
148 static void irda_usb_build_header(struct irda_usb_cb *self, irda_usb_build_header() argument
156 if (self->capability & IUC_STIR421X && irda_usb_build_header()
157 ((self->new_speed != -1) || (self->new_xbofs != -1))) { irda_usb_build_header()
162 if (self->new_speed == -1) irda_usb_build_header()
163 self->new_speed = self->speed ; irda_usb_build_header()
165 if (self->new_xbofs == -1) irda_usb_build_header()
166 self->new_xbofs = self->xbofs ; irda_usb_build_header()
170 if (self->new_speed != -1) { irda_usb_build_header()
175 if ((self->capability & IUC_SPEED_BUG) && irda_usb_build_header()
176 (!force) && (self->speed != -1)) { irda_usb_build_header()
185 __func__, self->new_speed); irda_usb_build_header()
186 self->speed = self->new_speed; irda_usb_build_header()
187 /* We will do ` self->new_speed = -1; ' in the completion irda_usb_build_header()
190 switch (self->speed) { irda_usb_build_header()
218 self->new_xbofs = 0; irda_usb_build_header()
222 self->new_xbofs = 0; irda_usb_build_header()
230 if (self->new_xbofs != -1) { irda_usb_build_header()
232 __func__, self->new_xbofs); irda_usb_build_header()
233 self->xbofs = self->new_xbofs; irda_usb_build_header()
234 /* We will do ` self->new_xbofs = -1; ' in the completion irda_usb_build_header()
237 switch (self->xbofs) { irda_usb_build_header()
300 static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self) irda_usb_change_speed_xbofs() argument
307 self->new_speed, self->new_xbofs); irda_usb_change_speed_xbofs()
310 urb = self->speed_urb; irda_usb_change_speed_xbofs()
317 frame = self->speed_buff; irda_usb_change_speed_xbofs()
320 irda_usb_build_header(self, frame, 1); irda_usb_change_speed_xbofs()
322 if (self->capability & IUC_STIR421X) { irda_usb_change_speed_xbofs()
329 usb_fill_bulk_urb(urb, self->usbdev, irda_usb_change_speed_xbofs()
330 usb_sndbulkpipe(self->usbdev, self->bulk_out_ep), irda_usb_change_speed_xbofs()
332 speed_bulk_callback, self); irda_usb_change_speed_xbofs()
333 urb->transfer_buffer_length = self->header_length; irda_usb_change_speed_xbofs()
349 struct irda_usb_cb *self = urb->context; speed_bulk_callback() local
352 IRDA_ASSERT(self != NULL, return;); speed_bulk_callback()
354 IRDA_ASSERT(urb == self->speed_urb, return;); speed_bulk_callback()
374 self->new_speed = -1; speed_bulk_callback()
375 self->new_xbofs = -1; speed_bulk_callback()
378 netif_wake_queue(self->netdev); speed_bulk_callback()
388 struct irda_usb_cb *self = netdev_priv(netdev); irda_usb_hard_xmit() local
389 struct urb *urb = self->tx_urb; irda_usb_hard_xmit()
400 spin_lock_irqsave(&self->lock, flags); irda_usb_hard_xmit()
403 * We need to check self->present under the spinlock because irda_usb_hard_xmit()
405 if (!self->present) { irda_usb_hard_xmit()
412 if ((xbofs != self->xbofs) && (xbofs != -1)) { irda_usb_hard_xmit()
413 self->new_xbofs = xbofs; irda_usb_hard_xmit()
418 if ((speed != self->speed) && (speed != -1)) { irda_usb_hard_xmit()
420 self->new_speed = speed; irda_usb_hard_xmit()
431 irda_usb_change_speed_xbofs(self); irda_usb_hard_xmit()
443 skb_copy_from_linear_data(skb, self->tx_buff + self->header_length, skb->len); irda_usb_hard_xmit()
446 if (self->capability & IUC_STIR421X) { irda_usb_hard_xmit()
448 __u8* frame = self->tx_buff; irda_usb_hard_xmit()
450 irda_usb_build_header(self, frame, 0); irda_usb_hard_xmit()
462 irda_usb_build_header(self, self->tx_buff, 0); irda_usb_hard_xmit()
466 ((struct irda_skb_cb *)skb->cb)->context = self; irda_usb_hard_xmit()
468 usb_fill_bulk_urb(urb, self->usbdev, irda_usb_hard_xmit()
469 usb_sndbulkpipe(self->usbdev, self->bulk_out_ep), irda_usb_hard_xmit()
470 self->tx_buff, skb->len + self->header_length, irda_usb_hard_xmit()
494 if (self->capability & IUC_NO_TURN) { irda_usb_hard_xmit()
498 diff = ktime_us_delta(ktime_get(), self->stamp); irda_usb_hard_xmit()
531 spin_unlock_irqrestore(&self->lock, flags); irda_usb_hard_xmit()
538 spin_unlock_irqrestore(&self->lock, flags); irda_usb_hard_xmit()
550 struct irda_usb_cb *self = ((struct irda_skb_cb *) skb->cb)->context; write_bulk_callback() local
553 IRDA_ASSERT(self != NULL, return;); write_bulk_callback()
555 IRDA_ASSERT(urb == self->tx_urb, return;); write_bulk_callback()
579 /* Make sure we read self->present properly */ write_bulk_callback()
580 spin_lock_irqsave(&self->lock, flags); write_bulk_callback()
583 if ((!self->netopen) || (!self->present)) { write_bulk_callback()
585 spin_unlock_irqrestore(&self->lock, flags); write_bulk_callback()
590 if ((self->new_speed != -1) || (self->new_xbofs != -1)) { write_bulk_callback()
591 if ((self->new_speed != self->speed) || write_bulk_callback()
592 (self->new_xbofs != self->xbofs)) { write_bulk_callback()
596 irda_usb_change_speed_xbofs(self); write_bulk_callback()
599 self->new_speed = -1; write_bulk_callback()
600 self->new_xbofs = -1; write_bulk_callback()
602 netif_wake_queue(self->netdev); write_bulk_callback()
606 netif_wake_queue(self->netdev); write_bulk_callback()
608 spin_unlock_irqrestore(&self->lock, flags); write_bulk_callback()
623 struct irda_usb_cb *self = netdev_priv(netdev); irda_usb_net_timeout() local
628 IRDA_ASSERT(self != NULL, return;); irda_usb_net_timeout()
631 spin_lock_irqsave(&self->lock, flags); irda_usb_net_timeout()
633 /* self->present *MUST* be read under spinlock */ irda_usb_net_timeout()
634 if (!self->present) { irda_usb_net_timeout()
637 spin_unlock_irqrestore(&self->lock, flags); irda_usb_net_timeout()
642 urb = self->speed_urb; irda_usb_net_timeout()
659 netif_wake_queue(self->netdev); irda_usb_net_timeout()
666 urb = self->tx_urb; irda_usb_net_timeout()
678 if(self->new_speed == -1) irda_usb_net_timeout()
679 self->new_speed = self->speed; irda_usb_net_timeout()
680 if(self->new_xbofs == -1) irda_usb_net_timeout()
681 self->new_xbofs = self->xbofs; irda_usb_net_timeout()
682 irda_usb_change_speed_xbofs(self); irda_usb_net_timeout()
703 netif_wake_queue(self->netdev); irda_usb_net_timeout()
708 spin_unlock_irqrestore(&self->lock, flags); irda_usb_net_timeout()
755 static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struct urb *urb) irda_usb_submit() argument
766 cb->context = self; irda_usb_submit()
769 usb_fill_bulk_urb(urb, self->usbdev, irda_usb_submit()
770 usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep), irda_usb_submit()
795 struct irda_usb_cb *self; irda_usb_receive() local
807 self = (struct irda_usb_cb *) cb->context; irda_usb_receive()
808 IRDA_ASSERT(self != NULL, return;); irda_usb_receive()
811 if ((!self->netopen) || (!self->present)) { irda_usb_receive()
821 self->netdev->stats.rx_crc_errors++; irda_usb_receive()
834 self->netdev->stats.rx_errors++; irda_usb_receive()
849 self->rx_defer_timer.function = irda_usb_rx_defer_expired; irda_usb_receive()
850 self->rx_defer_timer.data = (unsigned long) urb; irda_usb_receive()
851 mod_timer(&self->rx_defer_timer, jiffies + (10 * HZ / 1000)); irda_usb_receive()
856 if (urb->actual_length <= self->header_length) { irda_usb_receive()
866 self->stamp = ktime_get(); irda_usb_receive()
877 if (self->capability & IUC_STIR421X) irda_usb_receive()
886 self->netdev->stats.rx_dropped++; irda_usb_receive()
913 skb_pull(dataskb, self->header_length); irda_usb_receive()
916 dataskb->dev = self->netdev; irda_usb_receive()
923 self->netdev->stats.rx_bytes += len; irda_usb_receive()
924 self->netdev->stats.rx_packets++; irda_usb_receive()
938 next_urb = self->idle_rx_urb; irda_usb_receive()
942 self->idle_rx_urb = urb; irda_usb_receive()
946 irda_usb_submit(self, skb, next_urb); irda_usb_receive()
958 struct irda_usb_cb *self; irda_usb_rx_defer_expired() local
965 self = (struct irda_usb_cb *) cb->context; irda_usb_rx_defer_expired()
966 IRDA_ASSERT(self != NULL, return;); irda_usb_rx_defer_expired()
969 next_urb = self->idle_rx_urb; irda_usb_rx_defer_expired()
971 self->idle_rx_urb = urb; irda_usb_rx_defer_expired()
972 irda_usb_submit(self, skb, next_urb); irda_usb_rx_defer_expired()
980 static int irda_usb_is_receiving(struct irda_usb_cb *self) irda_usb_is_receiving() argument
1010 * Function stir421x_fwupload (struct irda_usb_cb *self,
1016 static int stir421x_fw_upload(struct irda_usb_cb *self, stir421x_fw_upload() argument
1040 ret = usb_bulk_msg(self->usbdev, stir421x_fw_upload()
1041 usb_sndbulkpipe(self->usbdev, stir421x_fw_upload()
1042 self->bulk_out_ep), stir421x_fw_upload()
1060 * Function stir421x_patch_device(struct irda_usb_cb *self)
1064 static int stir421x_patch_device(struct irda_usb_cb *self) stir421x_patch_device() argument
1078 self->usbdev->descriptor.bcdDevice); stir421x_patch_device()
1079 ret = request_firmware(&fw, stir421x_fw_name, &self->usbdev->dev); stir421x_patch_device()
1113 if (self->usbdev->descriptor.bcdDevice == cpu_to_le16(fw_version)) { stir421x_patch_device()
1129 ret = stir421x_fw_upload(self, &fw->data[i], stir421x_patch_device()
1156 * Note : don't mess with self->netopen - Jean II
1160 struct irda_usb_cb *self; irda_usb_net_open() local
1166 self = netdev_priv(netdev); irda_usb_net_open()
1167 IRDA_ASSERT(self != NULL, return -1;); irda_usb_net_open()
1169 spin_lock_irqsave(&self->lock, flags); irda_usb_net_open()
1171 if(!self->present) { irda_usb_net_open()
1172 spin_unlock_irqrestore(&self->lock, flags); irda_usb_net_open()
1177 if(self->needspatch) { irda_usb_net_open()
1178 spin_unlock_irqrestore(&self->lock, flags); irda_usb_net_open()
1185 self->speed = -1; irda_usb_net_open()
1186 self->xbofs = -1; irda_usb_net_open()
1187 self->new_speed = -1; irda_usb_net_open()
1188 self->new_xbofs = -1; irda_usb_net_open()
1192 self->netopen = 1; irda_usb_net_open()
1193 spin_unlock_irqrestore(&self->lock, flags); irda_usb_net_open()
1200 sprintf(hwname, "usb#%d", self->usbdev->devnum); irda_usb_net_open()
1201 self->irlap = irlap_open(netdev, &self->qos, hwname); irda_usb_net_open()
1202 IRDA_ASSERT(self->irlap != NULL, return -1;); irda_usb_net_open()
1211 self->idle_rx_urb = self->rx_urb[IU_MAX_ACTIVE_RX_URBS]; irda_usb_net_open()
1212 self->idle_rx_urb->context = NULL; irda_usb_net_open()
1224 irda_usb_submit(self, skb, self->rx_urb[i]); irda_usb_net_open()
1233 * Function irda_usb_net_close (self)
1240 struct irda_usb_cb *self; irda_usb_net_close() local
1244 self = netdev_priv(netdev); irda_usb_net_close()
1245 IRDA_ASSERT(self != NULL, return -1;); irda_usb_net_close()
1249 self->netopen = 0; irda_usb_net_close()
1255 del_timer(&self->rx_defer_timer); irda_usb_net_close()
1258 for (i = 0; i < self->max_rx_urb; i++) { irda_usb_net_close()
1259 struct urb *urb = self->rx_urb[i]; irda_usb_net_close()
1270 usb_kill_urb(self->tx_urb); irda_usb_net_close()
1271 usb_kill_urb(self->speed_urb); irda_usb_net_close()
1274 if (self->irlap) irda_usb_net_close()
1275 irlap_close(self->irlap); irda_usb_net_close()
1276 self->irlap = NULL; irda_usb_net_close()
1289 struct irda_usb_cb *self; irda_usb_net_ioctl() local
1293 self = netdev_priv(dev); irda_usb_net_ioctl()
1294 IRDA_ASSERT(self != NULL, return -1;); irda_usb_net_ioctl()
1303 spin_lock_irqsave(&self->lock, flags); irda_usb_net_ioctl()
1305 if(self->present) { irda_usb_net_ioctl()
1307 self->new_speed = irq->ifr_baudrate; irda_usb_net_ioctl()
1308 irda_usb_change_speed_xbofs(self); irda_usb_net_ioctl()
1310 spin_unlock_irqrestore(&self->lock, flags); irda_usb_net_ioctl()
1316 if(self->netopen) irda_usb_net_ioctl()
1317 irda_device_set_media_busy(self->netdev, TRUE); irda_usb_net_ioctl()
1320 irq->ifr_receiving = irda_usb_is_receiving(self); irda_usb_net_ioctl()
1342 static inline void irda_usb_init_qos(struct irda_usb_cb *self) irda_usb_init_qos() argument
1347 desc = self->irda_desc; irda_usb_init_qos()
1350 irda_init_max_qos_capabilies(&self->qos); irda_usb_init_qos()
1355 self->qos.baud_rate.bits = le16_to_cpu(desc->wBaudRate); irda_usb_init_qos()
1356 self->qos.min_turn_time.bits = desc->bmMinTurnaroundTime; irda_usb_init_qos()
1357 self->qos.additional_bofs.bits = desc->bmAdditionalBOFs; irda_usb_init_qos()
1358 self->qos.window_size.bits = desc->bmWindowSize; irda_usb_init_qos()
1359 self->qos.data_size.bits = desc->bmDataSize; irda_usb_init_qos()
1362 __func__, self->qos.baud_rate.bits, self->qos.data_size.bits, irda_usb_init_qos()
1363 self->qos.window_size.bits, self->qos.additional_bofs.bits, irda_usb_init_qos()
1364 self->qos.min_turn_time.bits); irda_usb_init_qos()
1367 if(self->capability & IUC_SIR_ONLY) irda_usb_init_qos()
1368 self->qos.baud_rate.bits &= 0x00ff; irda_usb_init_qos()
1369 if(self->capability & IUC_SMALL_PKT) irda_usb_init_qos()
1370 self->qos.data_size.bits = 0x07; irda_usb_init_qos()
1371 if(self->capability & IUC_NO_WINDOW) irda_usb_init_qos()
1372 self->qos.window_size.bits = 0x01; irda_usb_init_qos()
1373 if(self->capability & IUC_MAX_WINDOW) irda_usb_init_qos()
1374 self->qos.window_size.bits = 0x7f; irda_usb_init_qos()
1375 if(self->capability & IUC_MAX_XBOFS) irda_usb_init_qos()
1376 self->qos.additional_bofs.bits = 0x01; irda_usb_init_qos()
1381 self->qos.min_turn_time.bits = qos_mtt_bits; irda_usb_init_qos()
1387 irda_qos_bits_to_value(&self->qos); irda_usb_init_qos()
1403 static inline int irda_usb_open(struct irda_usb_cb *self) irda_usb_open() argument
1405 struct net_device *netdev = self->netdev; irda_usb_open()
1409 irda_usb_init_qos(self); irda_usb_open()
1419 static inline void irda_usb_close(struct irda_usb_cb *self) irda_usb_close() argument
1422 unregister_netdev(self->netdev); irda_usb_close()
1425 kfree(self->speed_buff); irda_usb_close()
1426 self->speed_buff = NULL; irda_usb_close()
1428 kfree(self->tx_buff); irda_usb_close()
1429 self->tx_buff = NULL; irda_usb_close()
1451 static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_host_endpoint *endpoint, int ennum) irda_usb_parse_endpoints() argument
1456 self->bulk_in_ep = 0; irda_usb_parse_endpoints()
1457 self->bulk_out_ep = 0; irda_usb_parse_endpoints()
1458 self->bulk_int_ep = 0; irda_usb_parse_endpoints()
1480 self->bulk_in_ep = ep; irda_usb_parse_endpoints()
1483 self->bulk_out_ep = ep; irda_usb_parse_endpoints()
1484 self->bulk_out_mtu = psize; irda_usb_parse_endpoints()
1490 self->bulk_int_ep = ep; irda_usb_parse_endpoints()
1499 __func__, self->bulk_in_ep, self->bulk_out_ep, irda_usb_parse_endpoints()
1500 self->bulk_out_mtu, self->bulk_int_ep); irda_usb_parse_endpoints()
1502 return (self->bulk_in_ep != 0) && (self->bulk_out_ep != 0); irda_usb_parse_endpoints()
1600 struct irda_usb_cb *self; irda_usb_probe() local
1615 net = alloc_irdadev(sizeof(*self)); irda_usb_probe()
1620 self = netdev_priv(net); irda_usb_probe()
1621 self->netdev = net; irda_usb_probe()
1622 spin_lock_init(&self->lock); irda_usb_probe()
1623 init_timer(&self->rx_defer_timer); irda_usb_probe()
1625 self->capability = id->driver_info; irda_usb_probe()
1626 self->needspatch = ((self->capability & IUC_STIR421X) != 0); irda_usb_probe()
1629 if (self->capability & IUC_STIR421X) { irda_usb_probe()
1630 self->max_rx_urb = IU_SIGMATEL_MAX_RX_URBS; irda_usb_probe()
1631 self->header_length = USB_IRDA_STIR421X_HEADER; irda_usb_probe()
1633 self->max_rx_urb = IU_MAX_RX_URBS; irda_usb_probe()
1634 self->header_length = USB_IRDA_HEADER; irda_usb_probe()
1637 self->rx_urb = kcalloc(self->max_rx_urb, sizeof(struct urb *), irda_usb_probe()
1639 if (!self->rx_urb) irda_usb_probe()
1642 for (i = 0; i < self->max_rx_urb; i++) { irda_usb_probe()
1643 self->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL); irda_usb_probe()
1644 if (!self->rx_urb[i]) { irda_usb_probe()
1648 self->tx_urb = usb_alloc_urb(0, GFP_KERNEL); irda_usb_probe()
1649 if (!self->tx_urb) { irda_usb_probe()
1652 self->speed_urb = usb_alloc_urb(0, GFP_KERNEL); irda_usb_probe()
1653 if (!self->speed_urb) { irda_usb_probe()
1689 if(!irda_usb_parse_endpoints(self, interface->endpoint, irda_usb_probe()
1696 self->usbdev = dev; irda_usb_probe()
1704 if (self->needspatch) { irda_usb_probe()
1705 ret = usb_control_msg (self->usbdev, usb_sndctrlpipe (self->usbdev, 0), irda_usb_probe()
1715 self->irda_desc = irda_desc; irda_usb_probe()
1716 self->present = 1; irda_usb_probe()
1717 self->netopen = 0; irda_usb_probe()
1718 self->usbintf = intf; irda_usb_probe()
1724 self->speed_buff = kzalloc(IRDA_USB_SPEED_MTU, GFP_KERNEL); irda_usb_probe()
1725 if (!self->speed_buff) irda_usb_probe()
1728 self->tx_buff = kzalloc(IRDA_SKB_MAX_MTU + self->header_length, irda_usb_probe()
1730 if (!self->tx_buff) irda_usb_probe()
1733 ret = irda_usb_open(self); irda_usb_probe()
1738 usb_set_intfdata(intf, self); irda_usb_probe()
1740 if (self->needspatch) { irda_usb_probe()
1742 ret = stir421x_patch_device(self); irda_usb_probe()
1743 self->needspatch = (ret < 0); irda_usb_probe()
1744 if (self->needspatch) { irda_usb_probe()
1750 irda_desc = irda_usb_find_class_desc (self->usbintf); irda_usb_probe()
1755 kfree(self->irda_desc); irda_usb_probe()
1756 self->irda_desc = irda_desc; irda_usb_probe()
1757 irda_usb_init_qos(self); irda_usb_probe()
1762 unregister_netdev(self->netdev); irda_usb_probe()
1764 kfree(self->tx_buff); irda_usb_probe()
1766 kfree(self->speed_buff); irda_usb_probe()
1769 usb_free_urb(self->speed_urb); irda_usb_probe()
1771 usb_free_urb(self->tx_urb); irda_usb_probe()
1773 for (i = 0; i < self->max_rx_urb; i++) irda_usb_probe()
1774 usb_free_urb(self->rx_urb[i]); irda_usb_probe()
1775 kfree(self->rx_urb); irda_usb_probe()
1797 struct irda_usb_cb *self = usb_get_intfdata(intf); irda_usb_disconnect() local
1801 if (!self) irda_usb_disconnect()
1805 spin_lock_irqsave(&self->lock, flags); irda_usb_disconnect()
1809 self->present = 0; irda_usb_disconnect()
1812 del_timer(&self->rx_defer_timer); irda_usb_disconnect()
1816 spin_unlock_irqrestore(&self->lock, flags); irda_usb_disconnect()
1819 if((self->netopen) || (self->irlap)) { irda_usb_disconnect()
1821 /*netif_device_detach(self->netdev);*/ irda_usb_disconnect()
1822 netif_stop_queue(self->netdev); irda_usb_disconnect()
1824 for (i = 0; i < self->max_rx_urb; i++) irda_usb_disconnect()
1825 usb_kill_urb(self->rx_urb[i]); irda_usb_disconnect()
1828 usb_kill_urb(self->tx_urb); irda_usb_disconnect()
1829 usb_kill_urb(self->speed_urb); irda_usb_disconnect()
1833 irda_usb_close(self); irda_usb_disconnect()
1835 self->usbdev = NULL; irda_usb_disconnect()
1836 self->usbintf = NULL; irda_usb_disconnect()
1839 for (i = 0; i < self->max_rx_urb; i++) irda_usb_disconnect()
1840 usb_free_urb(self->rx_urb[i]); irda_usb_disconnect()
1841 kfree(self->rx_urb); irda_usb_disconnect()
1843 usb_free_urb(self->tx_urb); irda_usb_disconnect()
1844 usb_free_urb(self->speed_urb); irda_usb_disconnect()
1846 /* Free self and network device */ irda_usb_disconnect()
1847 free_netdev(self->netdev); irda_usb_disconnect()
1855 struct irda_usb_cb *self = usb_get_intfdata(intf); irda_usb_suspend() local
1858 netif_device_detach(self->netdev); irda_usb_suspend()
1860 if (self->tx_urb != NULL) irda_usb_suspend()
1861 usb_kill_urb(self->tx_urb); irda_usb_suspend()
1862 if (self->speed_urb != NULL) irda_usb_suspend()
1863 usb_kill_urb(self->speed_urb); irda_usb_suspend()
1864 for (i = 0; i < self->max_rx_urb; i++) { irda_usb_suspend()
1865 if (self->rx_urb[i] != NULL) irda_usb_suspend()
1866 usb_kill_urb(self->rx_urb[i]); irda_usb_suspend()
1874 struct irda_usb_cb *self = usb_get_intfdata(intf); irda_usb_resume() local
1877 for (i = 0; i < self->max_rx_urb; i++) { irda_usb_resume()
1878 if (self->rx_urb[i] != NULL) irda_usb_resume()
1879 usb_submit_urb(self->rx_urb[i], GFP_KERNEL); irda_usb_resume()
1882 netif_device_attach(self->netdev); irda_usb_resume()
|
| H A D | nsc-ircc.c | 172 static int nsc_ircc_close(struct nsc_ircc_cb *self);
174 static void nsc_ircc_pio_receive(struct nsc_ircc_cb *self);
175 static int nsc_ircc_dma_receive(struct nsc_ircc_cb *self);
176 static int nsc_ircc_dma_receive_complete(struct nsc_ircc_cb *self, int iobase);
182 static void nsc_ircc_dma_xmit(struct nsc_ircc_cb *self, int iobase);
183 static __u8 nsc_ircc_change_speed(struct nsc_ircc_cb *self, __u32 baud);
184 static int nsc_ircc_is_receiving(struct nsc_ircc_cb *self);
366 struct nsc_ircc_cb *self; nsc_ircc_open() local
396 self = netdev_priv(dev); nsc_ircc_open()
397 self->netdev = dev; nsc_ircc_open()
398 spin_lock_init(&self->lock); nsc_ircc_open()
400 /* Need to store self somewhere */ nsc_ircc_open()
401 dev_self[chip_index] = self; nsc_ircc_open()
402 self->index = chip_index; nsc_ircc_open()
405 self->io.cfg_base = info->cfg_base; nsc_ircc_open()
406 self->io.fir_base = info->fir_base; nsc_ircc_open()
407 self->io.irq = info->irq; nsc_ircc_open()
408 self->io.fir_ext = CHIP_IO_EXTENT; nsc_ircc_open()
409 self->io.dma = info->dma; nsc_ircc_open()
410 self->io.fifo_size = 32; nsc_ircc_open()
413 ret = request_region(self->io.fir_base, self->io.fir_ext, driver_name); nsc_ircc_open()
416 __func__, self->io.fir_base); nsc_ircc_open()
422 irda_init_max_qos_capabilies(&self->qos); nsc_ircc_open()
425 self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600| nsc_ircc_open()
428 self->qos.min_turn_time.bits = qos_mtt_bits; nsc_ircc_open()
429 irda_qos_bits_to_value(&self->qos); nsc_ircc_open()
432 self->rx_buff.truesize = 14384; nsc_ircc_open()
433 self->tx_buff.truesize = 14384; nsc_ircc_open()
436 self->rx_buff.head = nsc_ircc_open()
437 dma_zalloc_coherent(NULL, self->rx_buff.truesize, nsc_ircc_open()
438 &self->rx_buff_dma, GFP_KERNEL); nsc_ircc_open()
439 if (self->rx_buff.head == NULL) { nsc_ircc_open()
445 self->tx_buff.head = nsc_ircc_open()
446 dma_zalloc_coherent(NULL, self->tx_buff.truesize, nsc_ircc_open()
447 &self->tx_buff_dma, GFP_KERNEL); nsc_ircc_open()
448 if (self->tx_buff.head == NULL) { nsc_ircc_open()
453 self->rx_buff.in_frame = FALSE; nsc_ircc_open()
454 self->rx_buff.state = OUTSIDE_FRAME; nsc_ircc_open()
455 self->tx_buff.data = self->tx_buff.head; nsc_ircc_open()
456 self->rx_buff.data = self->rx_buff.head; nsc_ircc_open()
459 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; nsc_ircc_open()
460 self->tx_fifo.tail = self->tx_buff.head; nsc_ircc_open()
476 dongle_id = nsc_ircc_read_dongle_id(self->io.fir_base); nsc_ircc_open()
485 self->io.dongle_id = dongle_id; nsc_ircc_open()
486 nsc_ircc_init_dongle_interface(self->io.fir_base, dongle_id); nsc_ircc_open()
488 self->pldev = platform_device_register_simple(NSC_IRCC_DRIVER_NAME, nsc_ircc_open()
489 self->index, NULL, 0); nsc_ircc_open()
490 if (IS_ERR(self->pldev)) { nsc_ircc_open()
491 err = PTR_ERR(self->pldev); nsc_ircc_open()
494 platform_set_drvdata(self->pldev, self); nsc_ircc_open()
501 dma_free_coherent(NULL, self->tx_buff.truesize, nsc_ircc_open()
502 self->tx_buff.head, self->tx_buff_dma); nsc_ircc_open()
504 dma_free_coherent(NULL, self->rx_buff.truesize, nsc_ircc_open()
505 self->rx_buff.head, self->rx_buff_dma); nsc_ircc_open()
507 release_region(self->io.fir_base, self->io.fir_ext); nsc_ircc_open()
515 * Function nsc_ircc_close (self)
520 static int __exit nsc_ircc_close(struct nsc_ircc_cb *self) nsc_ircc_close() argument
524 IRDA_ASSERT(self != NULL, return -1;); nsc_ircc_close()
526 iobase = self->io.fir_base; nsc_ircc_close()
528 platform_device_unregister(self->pldev); nsc_ircc_close()
531 unregister_netdev(self->netdev); nsc_ircc_close()
535 __func__, self->io.fir_base); nsc_ircc_close()
536 release_region(self->io.fir_base, self->io.fir_ext); nsc_ircc_close()
538 if (self->tx_buff.head) nsc_ircc_close()
539 dma_free_coherent(NULL, self->tx_buff.truesize, nsc_ircc_close()
540 self->tx_buff.head, self->tx_buff_dma); nsc_ircc_close()
542 if (self->rx_buff.head) nsc_ircc_close()
543 dma_free_coherent(NULL, self->rx_buff.truesize, nsc_ircc_close()
544 self->rx_buff.head, self->rx_buff_dma); nsc_ircc_close()
546 dev_self[self->index] = NULL; nsc_ircc_close()
547 free_netdev(self->netdev); nsc_ircc_close()
1248 * Function nsc_ircc_change_speed (self, baud)
1254 static __u8 nsc_ircc_change_speed(struct nsc_ircc_cb *self, __u32 speed) nsc_ircc_change_speed() argument
1256 struct net_device *dev = self->netdev; nsc_ircc_change_speed()
1264 IRDA_ASSERT(self != NULL, return 0;); nsc_ircc_change_speed()
1266 iobase = self->io.fir_base; nsc_ircc_change_speed()
1269 self->io.speed = speed; nsc_ircc_change_speed()
1317 nsc_ircc_change_dongle_speed(iobase, speed, self->io.dongle_id); nsc_ircc_change_speed()
1340 nsc_ircc_dma_receive(self); nsc_ircc_change_speed()
1365 struct nsc_ircc_cb *self; nsc_ircc_hard_xmit_sir() local
1371 self = netdev_priv(dev); nsc_ircc_hard_xmit_sir()
1373 IRDA_ASSERT(self != NULL, return NETDEV_TX_OK;); nsc_ircc_hard_xmit_sir()
1375 iobase = self->io.fir_base; nsc_ircc_hard_xmit_sir()
1380 spin_lock_irqsave(&self->lock, flags); nsc_ircc_hard_xmit_sir()
1384 if ((speed != self->io.speed) && (speed != -1)) { nsc_ircc_hard_xmit_sir()
1391 if (self->io.direction == IO_RECV) { nsc_ircc_hard_xmit_sir()
1392 nsc_ircc_change_speed(self, speed); nsc_ircc_hard_xmit_sir()
1397 self->new_speed = speed; nsc_ircc_hard_xmit_sir()
1403 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_hard_xmit_sir()
1407 self->new_speed = speed; nsc_ircc_hard_xmit_sir()
1413 self->tx_buff.data = self->tx_buff.head; nsc_ircc_hard_xmit_sir()
1415 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, nsc_ircc_hard_xmit_sir()
1416 self->tx_buff.truesize); nsc_ircc_hard_xmit_sir()
1418 dev->stats.tx_bytes += self->tx_buff.len; nsc_ircc_hard_xmit_sir()
1428 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_hard_xmit_sir()
1438 struct nsc_ircc_cb *self; nsc_ircc_hard_xmit_fir() local
1445 self = netdev_priv(dev); nsc_ircc_hard_xmit_fir()
1446 iobase = self->io.fir_base; nsc_ircc_hard_xmit_fir()
1451 spin_lock_irqsave(&self->lock, flags); nsc_ircc_hard_xmit_fir()
1455 if ((speed != self->io.speed) && (speed != -1)) { nsc_ircc_hard_xmit_fir()
1460 if(self->tx_fifo.len == 0) { nsc_ircc_hard_xmit_fir()
1461 nsc_ircc_change_speed(self, speed); nsc_ircc_hard_xmit_fir()
1464 self->new_speed = speed; nsc_ircc_hard_xmit_fir()
1474 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_hard_xmit_fir()
1479 self->new_speed = speed; nsc_ircc_hard_xmit_fir()
1487 self->tx_fifo.queue[self->tx_fifo.free].start = self->tx_fifo.tail; nsc_ircc_hard_xmit_fir()
1488 self->tx_fifo.queue[self->tx_fifo.free].len = skb->len; nsc_ircc_hard_xmit_fir()
1489 self->tx_fifo.tail += skb->len; nsc_ircc_hard_xmit_fir()
1493 skb_copy_from_linear_data(skb, self->tx_fifo.queue[self->tx_fifo.free].start, nsc_ircc_hard_xmit_fir()
1495 self->tx_fifo.len++; nsc_ircc_hard_xmit_fir()
1496 self->tx_fifo.free++; nsc_ircc_hard_xmit_fir()
1499 if (self->tx_fifo.len == 1) { nsc_ircc_hard_xmit_fir()
1504 diff = ktime_us_delta(ktime_get(), self->stamp); nsc_ircc_hard_xmit_fir()
1528 self->io.direction = IO_XMIT; nsc_ircc_hard_xmit_fir()
1545 nsc_ircc_dma_xmit(self, iobase); nsc_ircc_hard_xmit_fir()
1550 if ((self->tx_fifo.free < MAX_TX_WINDOW) && (self->new_speed == 0)) nsc_ircc_hard_xmit_fir()
1551 netif_wake_queue(self->netdev); nsc_ircc_hard_xmit_fir()
1557 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_hard_xmit_fir()
1564 * Function nsc_ircc_dma_xmit (self, iobase)
1569 static void nsc_ircc_dma_xmit(struct nsc_ircc_cb *self, int iobase) nsc_ircc_dma_xmit() argument
1580 self->io.direction = IO_XMIT; nsc_ircc_dma_xmit()
1586 irda_setup_dma(self->io.dma, nsc_ircc_dma_xmit()
1587 ((u8 *)self->tx_fifo.queue[self->tx_fifo.ptr].start - nsc_ircc_dma_xmit()
1588 self->tx_buff.head) + self->tx_buff_dma, nsc_ircc_dma_xmit()
1589 self->tx_fifo.queue[self->tx_fifo.ptr].len, nsc_ircc_dma_xmit()
1601 * Function nsc_ircc_pio_xmit (self, iobase)
1640 * Function nsc_ircc_dma_xmit_complete (self)
1646 static int nsc_ircc_dma_xmit_complete(struct nsc_ircc_cb *self) nsc_ircc_dma_xmit_complete() argument
1652 iobase = self->io.fir_base; nsc_ircc_dma_xmit_complete()
1663 self->netdev->stats.tx_errors++; nsc_ircc_dma_xmit_complete()
1664 self->netdev->stats.tx_fifo_errors++; nsc_ircc_dma_xmit_complete()
1669 self->netdev->stats.tx_packets++; nsc_ircc_dma_xmit_complete()
1673 self->tx_fifo.ptr++; nsc_ircc_dma_xmit_complete()
1674 self->tx_fifo.len--; nsc_ircc_dma_xmit_complete()
1677 if (self->tx_fifo.len) { nsc_ircc_dma_xmit_complete()
1678 nsc_ircc_dma_xmit(self, iobase); nsc_ircc_dma_xmit_complete()
1684 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; nsc_ircc_dma_xmit_complete()
1685 self->tx_fifo.tail = self->tx_buff.head; nsc_ircc_dma_xmit_complete()
1690 if ((self->tx_fifo.free < MAX_TX_WINDOW) && (self->new_speed == 0)) { nsc_ircc_dma_xmit_complete()
1693 netif_wake_queue(self->netdev); nsc_ircc_dma_xmit_complete()
1703 * Function nsc_ircc_dma_receive (self)
1709 static int nsc_ircc_dma_receive(struct nsc_ircc_cb *self) nsc_ircc_dma_receive() argument
1714 iobase = self->io.fir_base; nsc_ircc_dma_receive()
1717 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; nsc_ircc_dma_receive()
1718 self->tx_fifo.tail = self->tx_buff.head; nsc_ircc_dma_receive()
1731 self->io.direction = IO_RECV; nsc_ircc_dma_receive()
1732 self->rx_buff.data = self->rx_buff.head; nsc_ircc_dma_receive()
1738 self->st_fifo.len = self->st_fifo.pending_bytes = 0; nsc_ircc_dma_receive()
1739 self->st_fifo.tail = self->st_fifo.head = 0; nsc_ircc_dma_receive()
1741 irda_setup_dma(self->io.dma, self->rx_buff_dma, self->rx_buff.truesize, nsc_ircc_dma_receive()
1755 * Function nsc_ircc_dma_receive_complete (self)
1761 static int nsc_ircc_dma_receive_complete(struct nsc_ircc_cb *self, int iobase) nsc_ircc_dma_receive_complete() argument
1769 st_fifo = &self->st_fifo; nsc_ircc_dma_receive_complete()
1804 self->netdev->stats.rx_errors += len; nsc_ircc_dma_receive_complete()
1807 self->netdev->stats.rx_errors++; nsc_ircc_dma_receive_complete()
1809 self->rx_buff.data += len; nsc_ircc_dma_receive_complete()
1812 self->netdev->stats.rx_length_errors++; nsc_ircc_dma_receive_complete()
1815 self->netdev->stats.rx_frame_errors++; nsc_ircc_dma_receive_complete()
1818 self->netdev->stats.rx_crc_errors++; nsc_ircc_dma_receive_complete()
1822 self->netdev->stats.rx_fifo_errors++; nsc_ircc_dma_receive_complete()
1825 self->netdev->stats.rx_fifo_errors++; nsc_ircc_dma_receive_complete()
1834 if (st_fifo->pending_bytes < self->io.fifo_size) { nsc_ircc_dma_receive_complete()
1867 self->stamp = ktime_get(); nsc_ircc_dma_receive_complete()
1871 self->netdev->stats.rx_dropped++; nsc_ircc_dma_receive_complete()
1883 if (self->io.speed < 4000000) { nsc_ircc_dma_receive_complete()
1886 self->rx_buff.data, nsc_ircc_dma_receive_complete()
1891 self->rx_buff.data, nsc_ircc_dma_receive_complete()
1896 self->rx_buff.data += len; nsc_ircc_dma_receive_complete()
1897 self->netdev->stats.rx_bytes += len; nsc_ircc_dma_receive_complete()
1898 self->netdev->stats.rx_packets++; nsc_ircc_dma_receive_complete()
1900 skb->dev = self->netdev; nsc_ircc_dma_receive_complete()
1913 * Function nsc_ircc_pio_receive (self)
1918 static void nsc_ircc_pio_receive(struct nsc_ircc_cb *self) nsc_ircc_pio_receive() argument
1923 iobase = self->io.fir_base; nsc_ircc_pio_receive()
1928 async_unwrap_char(self->netdev, &self->netdev->stats, nsc_ircc_pio_receive()
1929 &self->rx_buff, byte); nsc_ircc_pio_receive()
1934 * Function nsc_ircc_sir_interrupt (self, eir)
1939 static void nsc_ircc_sir_interrupt(struct nsc_ircc_cb *self, int eir) nsc_ircc_sir_interrupt() argument
1946 actual = nsc_ircc_pio_write(self->io.fir_base, nsc_ircc_sir_interrupt()
1947 self->tx_buff.data, nsc_ircc_sir_interrupt()
1948 self->tx_buff.len, nsc_ircc_sir_interrupt()
1949 self->io.fifo_size); nsc_ircc_sir_interrupt()
1950 self->tx_buff.data += actual; nsc_ircc_sir_interrupt()
1951 self->tx_buff.len -= actual; nsc_ircc_sir_interrupt()
1953 self->io.direction = IO_XMIT; nsc_ircc_sir_interrupt()
1956 if (self->tx_buff.len > 0) nsc_ircc_sir_interrupt()
1957 self->ier = IER_TXLDL_IE; nsc_ircc_sir_interrupt()
1960 self->netdev->stats.tx_packets++; nsc_ircc_sir_interrupt()
1961 netif_wake_queue(self->netdev); nsc_ircc_sir_interrupt()
1962 self->ier = IER_TXEMP_IE; nsc_ircc_sir_interrupt()
1969 self->io.direction = IO_RECV; nsc_ircc_sir_interrupt()
1970 self->ier = IER_RXHDL_IE; nsc_ircc_sir_interrupt()
1972 * Need to be after self->io.direction to avoid race with nsc_ircc_sir_interrupt()
1974 if (self->new_speed) { nsc_ircc_sir_interrupt()
1976 self->ier = nsc_ircc_change_speed(self, nsc_ircc_sir_interrupt()
1977 self->new_speed); nsc_ircc_sir_interrupt()
1978 self->new_speed = 0; nsc_ircc_sir_interrupt()
1979 netif_wake_queue(self->netdev); nsc_ircc_sir_interrupt()
1982 if (self->io.speed > 115200) { nsc_ircc_sir_interrupt()
1991 nsc_ircc_pio_receive(self); nsc_ircc_sir_interrupt()
1994 self->ier = IER_RXHDL_IE; nsc_ircc_sir_interrupt()
1999 * Function nsc_ircc_fir_interrupt (self, eir)
2004 static void nsc_ircc_fir_interrupt(struct nsc_ircc_cb *self, int iobase, nsc_ircc_fir_interrupt() argument
2014 if (nsc_ircc_dma_receive_complete(self, iobase)) { nsc_ircc_fir_interrupt()
2016 self->ier = IER_SFIF_IE; nsc_ircc_fir_interrupt()
2018 self->ier = IER_SFIF_IE | IER_TMR_IE; nsc_ircc_fir_interrupt()
2030 if (self->io.direction == IO_XMIT) { nsc_ircc_fir_interrupt()
2031 nsc_ircc_dma_xmit(self, iobase); nsc_ircc_fir_interrupt()
2034 self->ier = IER_DMA_IE; nsc_ircc_fir_interrupt()
2037 if (nsc_ircc_dma_receive_complete(self, iobase)) { nsc_ircc_fir_interrupt()
2038 self->ier = IER_SFIF_IE; nsc_ircc_fir_interrupt()
2040 self->ier = IER_SFIF_IE | IER_TMR_IE; nsc_ircc_fir_interrupt()
2045 if (nsc_ircc_dma_xmit_complete(self)) { nsc_ircc_fir_interrupt()
2046 if(self->new_speed != 0) { nsc_ircc_fir_interrupt()
2050 self->ier = IER_TXEMP_IE; nsc_ircc_fir_interrupt()
2054 if (irda_device_txqueue_empty(self->netdev)) { nsc_ircc_fir_interrupt()
2056 nsc_ircc_dma_receive(self); nsc_ircc_fir_interrupt()
2057 self->ier = IER_SFIF_IE; nsc_ircc_fir_interrupt()
2064 self->ier = IER_DMA_IE; nsc_ircc_fir_interrupt()
2069 self->ier = nsc_ircc_change_speed(self, self->new_speed); nsc_ircc_fir_interrupt()
2070 self->new_speed = 0; nsc_ircc_fir_interrupt()
2071 netif_wake_queue(self->netdev); nsc_ircc_fir_interrupt()
2087 struct nsc_ircc_cb *self; nsc_ircc_interrupt() local
2091 self = netdev_priv(dev); nsc_ircc_interrupt()
2093 spin_lock(&self->lock); nsc_ircc_interrupt()
2095 iobase = self->io.fir_base; nsc_ircc_interrupt()
2100 self->ier = inb(iobase+IER); nsc_ircc_interrupt()
2101 eir = inb(iobase+EIR) & self->ier; /* Mask out the interesting ones */ nsc_ircc_interrupt()
2107 if (self->io.speed > 115200) nsc_ircc_interrupt()
2108 nsc_ircc_fir_interrupt(self, iobase, eir); nsc_ircc_interrupt()
2110 nsc_ircc_sir_interrupt(self, eir); nsc_ircc_interrupt()
2113 outb(self->ier, iobase+IER); /* Restore interrupts */ nsc_ircc_interrupt()
2116 spin_unlock(&self->lock); nsc_ircc_interrupt()
2121 * Function nsc_ircc_is_receiving (self)
2126 static int nsc_ircc_is_receiving(struct nsc_ircc_cb *self) nsc_ircc_is_receiving() argument
2133 IRDA_ASSERT(self != NULL, return FALSE;); nsc_ircc_is_receiving()
2135 spin_lock_irqsave(&self->lock, flags); nsc_ircc_is_receiving()
2137 if (self->io.speed > 115200) { nsc_ircc_is_receiving()
2138 iobase = self->io.fir_base; nsc_ircc_is_receiving()
2149 status = (self->rx_buff.state != OUTSIDE_FRAME); nsc_ircc_is_receiving()
2151 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_is_receiving()
2164 struct nsc_ircc_cb *self; nsc_ircc_net_open() local
2171 self = netdev_priv(dev); nsc_ircc_net_open()
2173 IRDA_ASSERT(self != NULL, return 0;); nsc_ircc_net_open()
2175 iobase = self->io.fir_base; nsc_ircc_net_open()
2177 if (request_irq(self->io.irq, nsc_ircc_interrupt, 0, dev->name, dev)) { nsc_ircc_net_open()
2179 driver_name, self->io.irq); nsc_ircc_net_open()
2186 if (request_dma(self->io.dma, dev->name)) { nsc_ircc_net_open()
2188 driver_name, self->io.dma); nsc_ircc_net_open()
2189 free_irq(self->io.irq, dev); nsc_ircc_net_open()
2206 /* Give self a hardware name */ nsc_ircc_net_open()
2207 sprintf(hwname, "NSC-FIR @ 0x%03x", self->io.fir_base); nsc_ircc_net_open()
2213 self->irlap = irlap_open(dev, &self->qos, hwname); nsc_ircc_net_open()
2226 struct nsc_ircc_cb *self; nsc_ircc_net_close() local
2233 self = netdev_priv(dev); nsc_ircc_net_close()
2234 IRDA_ASSERT(self != NULL, return 0;); nsc_ircc_net_close()
2240 if (self->irlap) nsc_ircc_net_close()
2241 irlap_close(self->irlap); nsc_ircc_net_close()
2242 self->irlap = NULL; nsc_ircc_net_close()
2244 iobase = self->io.fir_base; nsc_ircc_net_close()
2246 disable_dma(self->io.dma); nsc_ircc_net_close()
2255 free_irq(self->io.irq, dev); nsc_ircc_net_close()
2256 free_dma(self->io.dma); nsc_ircc_net_close()
2273 struct nsc_ircc_cb *self; nsc_ircc_net_ioctl() local
2279 self = netdev_priv(dev); nsc_ircc_net_ioctl()
2281 IRDA_ASSERT(self != NULL, return -1;); nsc_ircc_net_ioctl()
2291 spin_lock_irqsave(&self->lock, flags); nsc_ircc_net_ioctl()
2292 nsc_ircc_change_speed(self, irq->ifr_baudrate); nsc_ircc_net_ioctl()
2293 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_net_ioctl()
2300 irda_device_set_media_busy(self->netdev, TRUE); nsc_ircc_net_ioctl()
2304 irq->ifr_receiving = nsc_ircc_is_receiving(self); nsc_ircc_net_ioctl()
2314 struct nsc_ircc_cb *self = platform_get_drvdata(dev); nsc_ircc_suspend() local
2317 int iobase = self->io.fir_base; nsc_ircc_suspend()
2319 if (self->io.suspended) nsc_ircc_suspend()
2325 if (netif_running(self->netdev)) { nsc_ircc_suspend()
2326 netif_device_detach(self->netdev); nsc_ircc_suspend()
2327 spin_lock_irqsave(&self->lock, flags); nsc_ircc_suspend()
2338 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_suspend()
2339 free_irq(self->io.irq, self->netdev); nsc_ircc_suspend()
2340 disable_dma(self->io.dma); nsc_ircc_suspend()
2342 self->io.suspended = 1; nsc_ircc_suspend()
2350 struct nsc_ircc_cb *self = platform_get_drvdata(dev); nsc_ircc_resume() local
2353 if (!self->io.suspended) nsc_ircc_resume()
2359 nsc_ircc_setup(&self->io); nsc_ircc_resume()
2360 nsc_ircc_init_dongle_interface(self->io.fir_base, self->io.dongle_id); nsc_ircc_resume()
2362 if (netif_running(self->netdev)) { nsc_ircc_resume()
2363 if (request_irq(self->io.irq, nsc_ircc_interrupt, 0, nsc_ircc_resume()
2364 self->netdev->name, self->netdev)) { nsc_ircc_resume()
2366 driver_name, self->io.irq); nsc_ircc_resume()
2372 unregister_netdevice(self->netdev); nsc_ircc_resume()
2374 spin_lock_irqsave(&self->lock, flags); nsc_ircc_resume()
2375 nsc_ircc_change_speed(self, self->io.speed); nsc_ircc_resume()
2376 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_resume()
2377 netif_device_attach(self->netdev); nsc_ircc_resume()
2381 spin_lock_irqsave(&self->lock, flags); nsc_ircc_resume()
2382 nsc_ircc_change_speed(self, 9600); nsc_ircc_resume()
2383 spin_unlock_irqrestore(&self->lock, flags); nsc_ircc_resume()
2385 self->io.suspended = 0; nsc_ircc_resume()
|
| H A D | smsc-ircc2.c | 188 static void smsc_ircc_setup_io(struct smsc_ircc_cb *self, unsigned int fir_base, unsigned int sir_base, u8 dma, u8 irq);
189 static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self);
190 static void smsc_ircc_init_chip(struct smsc_ircc_cb *self);
191 static int __exit smsc_ircc_close(struct smsc_ircc_cb *self);
192 static int smsc_ircc_dma_receive(struct smsc_ircc_cb *self);
193 static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self);
194 static void smsc_ircc_sir_receive(struct smsc_ircc_cb *self);
199 static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int bofs);
200 static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self);
201 static void smsc_ircc_change_speed(struct smsc_ircc_cb *self, u32 speed);
202 static void smsc_ircc_set_sir_speed(struct smsc_ircc_cb *self, u32 speed);
205 static void smsc_ircc_sir_start(struct smsc_ircc_cb *self);
207 static void smsc_ircc_sir_stop(struct smsc_ircc_cb *self);
209 static void smsc_ircc_sir_write_wakeup(struct smsc_ircc_cb *self);
217 static int smsc_ircc_is_receiving(struct smsc_ircc_cb *self);
218 static void smsc_ircc_probe_transceiver(struct smsc_ircc_cb *self);
219 static void smsc_ircc_set_transceiver_for_speed(struct smsc_ircc_cb *self, u32 speed);
220 static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self);
496 struct smsc_ircc_cb *self = netdev_priv(dev); smsc_ircc_net_xmit() local
498 if (self->io.speed > 115200) smsc_ircc_net_xmit()
522 struct smsc_ircc_cb *self; smsc_ircc_open() local
553 self = netdev_priv(dev); smsc_ircc_open()
554 self->netdev = dev; smsc_ircc_open()
557 dev->base_addr = self->io.fir_base = fir_base; smsc_ircc_open()
558 dev->irq = self->io.irq = irq; smsc_ircc_open()
560 /* Need to store self somewhere */ smsc_ircc_open()
561 dev_self[dev_count] = self; smsc_ircc_open()
562 spin_lock_init(&self->lock); smsc_ircc_open()
564 self->rx_buff.truesize = SMSC_IRCC2_RX_BUFF_TRUESIZE; smsc_ircc_open()
565 self->tx_buff.truesize = SMSC_IRCC2_TX_BUFF_TRUESIZE; smsc_ircc_open()
567 self->rx_buff.head = smsc_ircc_open()
568 dma_zalloc_coherent(NULL, self->rx_buff.truesize, smsc_ircc_open()
569 &self->rx_buff_dma, GFP_KERNEL); smsc_ircc_open()
570 if (self->rx_buff.head == NULL) smsc_ircc_open()
573 self->tx_buff.head = smsc_ircc_open()
574 dma_zalloc_coherent(NULL, self->tx_buff.truesize, smsc_ircc_open()
575 &self->tx_buff_dma, GFP_KERNEL); smsc_ircc_open()
576 if (self->tx_buff.head == NULL) smsc_ircc_open()
579 self->rx_buff.in_frame = FALSE; smsc_ircc_open()
580 self->rx_buff.state = OUTSIDE_FRAME; smsc_ircc_open()
581 self->tx_buff.data = self->tx_buff.head; smsc_ircc_open()
582 self->rx_buff.data = self->rx_buff.head; smsc_ircc_open()
584 smsc_ircc_setup_io(self, fir_base, sir_base, dma, irq); smsc_ircc_open()
585 smsc_ircc_setup_qos(self); smsc_ircc_open()
586 smsc_ircc_init_chip(self); smsc_ircc_open()
590 self->transceiver = ircc_transceiver; smsc_ircc_open()
592 smsc_ircc_probe_transceiver(self); smsc_ircc_open()
594 err = register_netdev(self->netdev); smsc_ircc_open()
601 self->pldev = platform_device_register_simple(SMSC_IRCC2_DRIVER_NAME, smsc_ircc_open()
603 if (IS_ERR(self->pldev)) { smsc_ircc_open()
604 err = PTR_ERR(self->pldev); smsc_ircc_open()
607 platform_set_drvdata(self->pldev, self); smsc_ircc_open()
615 unregister_netdev(self->netdev); smsc_ircc_open()
618 dma_free_coherent(NULL, self->tx_buff.truesize, smsc_ircc_open()
619 self->tx_buff.head, self->tx_buff_dma); smsc_ircc_open()
621 dma_free_coherent(NULL, self->rx_buff.truesize, smsc_ircc_open()
622 self->rx_buff.head, self->rx_buff_dma); smsc_ircc_open()
624 free_netdev(self->netdev); smsc_ircc_open()
687 * Function smsc_ircc_setup_io(self, fir_base, sir_base, dma, irq)
692 static void smsc_ircc_setup_io(struct smsc_ircc_cb *self, smsc_ircc_setup_io() argument
703 self->io.fir_base = fir_base; smsc_ircc_setup_io()
704 self->io.sir_base = sir_base; smsc_ircc_setup_io()
705 self->io.fir_ext = SMSC_IRCC2_FIR_CHIP_IO_EXTENT; smsc_ircc_setup_io()
706 self->io.sir_ext = SMSC_IRCC2_SIR_CHIP_IO_EXTENT; smsc_ircc_setup_io()
707 self->io.fifo_size = SMSC_IRCC2_FIFO_SIZE; smsc_ircc_setup_io()
708 self->io.speed = SMSC_IRCC2_C_IRDA_FALLBACK_SPEED; smsc_ircc_setup_io()
714 self->io.irq = irq; smsc_ircc_setup_io()
716 self->io.irq = chip_irq; smsc_ircc_setup_io()
722 self->io.dma = dma; smsc_ircc_setup_io()
724 self->io.dma = chip_dma; smsc_ircc_setup_io()
729 * Function smsc_ircc_setup_qos(self)
734 static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self) smsc_ircc_setup_qos() argument
737 irda_init_max_qos_capabilies(&self->qos); smsc_ircc_setup_qos()
739 self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600| smsc_ircc_setup_qos()
742 self->qos.min_turn_time.bits = SMSC_IRCC2_MIN_TURN_TIME; smsc_ircc_setup_qos()
743 self->qos.window_size.bits = SMSC_IRCC2_WINDOW_SIZE; smsc_ircc_setup_qos()
744 irda_qos_bits_to_value(&self->qos); smsc_ircc_setup_qos()
748 * Function smsc_ircc_init_chip(self)
753 static void smsc_ircc_init_chip(struct smsc_ircc_cb *self) smsc_ircc_init_chip() argument
755 int iobase = self->io.fir_base; smsc_ircc_init_chip()
781 smsc_ircc_set_sir_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED); smsc_ircc_init_chip()
796 struct smsc_ircc_cb *self; smsc_ircc_net_ioctl() local
802 self = netdev_priv(dev); smsc_ircc_net_ioctl()
804 IRDA_ASSERT(self != NULL, return -1;); smsc_ircc_net_ioctl()
814 * self->io.speed and the hardware - Jean II */ smsc_ircc_net_ioctl()
815 spin_lock_irqsave(&self->lock, flags); smsc_ircc_net_ioctl()
816 smsc_ircc_change_speed(self, irq->ifr_baudrate); smsc_ircc_net_ioctl()
817 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_net_ioctl()
826 irda_device_set_media_busy(self->netdev, TRUE); smsc_ircc_net_ioctl()
829 irq->ifr_receiving = smsc_ircc_is_receiving(self); smsc_ircc_net_ioctl()
857 struct smsc_ircc_cb *self = netdev_priv(dev); smsc_ircc_timeout() local
861 dev->name, self->io.speed); smsc_ircc_timeout()
862 spin_lock_irqsave(&self->lock, flags); smsc_ircc_timeout()
863 smsc_ircc_sir_start(self); smsc_ircc_timeout()
864 smsc_ircc_change_speed(self, self->io.speed); smsc_ircc_timeout()
867 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_timeout()
881 struct smsc_ircc_cb *self; smsc_ircc_hard_xmit_sir() local
889 self = netdev_priv(dev); smsc_ircc_hard_xmit_sir()
890 IRDA_ASSERT(self != NULL, return NETDEV_TX_OK;); smsc_ircc_hard_xmit_sir()
894 /* Make sure test of self->io.speed & speed change are atomic */ smsc_ircc_hard_xmit_sir()
895 spin_lock_irqsave(&self->lock, flags); smsc_ircc_hard_xmit_sir()
899 if (speed != self->io.speed && speed != -1) { smsc_ircc_hard_xmit_sir()
911 smsc_ircc_sir_wait_hw_transmitter_finish(self); smsc_ircc_hard_xmit_sir()
912 smsc_ircc_change_speed(self, speed); smsc_ircc_hard_xmit_sir()
913 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_hard_xmit_sir()
917 self->new_speed = speed; smsc_ircc_hard_xmit_sir()
921 self->tx_buff.data = self->tx_buff.head; smsc_ircc_hard_xmit_sir()
924 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, smsc_ircc_hard_xmit_sir()
925 self->tx_buff.truesize); smsc_ircc_hard_xmit_sir()
927 dev->stats.tx_bytes += self->tx_buff.len; smsc_ircc_hard_xmit_sir()
930 outb(UART_IER_THRI, self->io.sir_base + UART_IER); smsc_ircc_hard_xmit_sir()
932 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_hard_xmit_sir()
940 * Function smsc_ircc_set_fir_speed (self, baud)
945 static void smsc_ircc_set_fir_speed(struct smsc_ircc_cb *self, u32 speed) smsc_ircc_set_fir_speed() argument
949 IRDA_ASSERT(self != NULL, return;); smsc_ircc_set_fir_speed()
950 fir_base = self->io.fir_base; smsc_ircc_set_fir_speed()
952 self->io.speed = speed; smsc_ircc_set_fir_speed()
992 * Function smsc_ircc_fir_start(self)
997 static void smsc_ircc_fir_start(struct smsc_ircc_cb *self) smsc_ircc_fir_start() argument
1004 IRDA_ASSERT(self != NULL, return;); smsc_ircc_fir_start()
1005 dev = self->netdev; smsc_ircc_fir_start()
1008 fir_base = self->io.fir_base; smsc_ircc_fir_start()
1038 * Function smsc_ircc_fir_stop(self, baud)
1043 static void smsc_ircc_fir_stop(struct smsc_ircc_cb *self) smsc_ircc_fir_stop() argument
1049 IRDA_ASSERT(self != NULL, return;); smsc_ircc_fir_stop()
1051 fir_base = self->io.fir_base; smsc_ircc_fir_stop()
1059 * Function smsc_ircc_change_speed(self, baud)
1066 static void smsc_ircc_change_speed(struct smsc_ircc_cb *self, u32 speed) smsc_ircc_change_speed() argument
1073 IRDA_ASSERT(self != NULL, return;); smsc_ircc_change_speed()
1074 dev = self->netdev; smsc_ircc_change_speed()
1076 last_speed_was_sir = self->io.speed <= SMSC_IRCC2_MAX_SIR_SPEED; smsc_ircc_change_speed()
1081 self->io.speed = speed; smsc_ircc_change_speed()
1083 smsc_ircc_fir_start(self); smsc_ircc_change_speed()
1086 if (self->io.speed == 0) smsc_ircc_change_speed()
1087 smsc_ircc_sir_start(self); smsc_ircc_change_speed()
1090 if (!last_speed_was_sir) speed = self->io.speed; smsc_ircc_change_speed()
1093 if (self->io.speed != speed) smsc_ircc_change_speed()
1094 smsc_ircc_set_transceiver_for_speed(self, speed); smsc_ircc_change_speed()
1096 self->io.speed = speed; smsc_ircc_change_speed()
1100 smsc_ircc_fir_stop(self); smsc_ircc_change_speed()
1101 smsc_ircc_sir_start(self); smsc_ircc_change_speed()
1103 smsc_ircc_set_sir_speed(self, speed); smsc_ircc_change_speed()
1107 smsc_ircc_sir_stop(self); smsc_ircc_change_speed()
1109 smsc_ircc_fir_start(self); smsc_ircc_change_speed()
1111 smsc_ircc_set_fir_speed(self, speed); smsc_ircc_change_speed()
1114 self->tx_buff.len = 10; smsc_ircc_change_speed()
1115 self->tx_buff.data = self->tx_buff.head; smsc_ircc_change_speed()
1117 smsc_ircc_dma_xmit(self, 4000); smsc_ircc_change_speed()
1120 smsc_ircc_dma_receive(self); smsc_ircc_change_speed()
1127 * Function smsc_ircc_set_sir_speed (self, speed)
1132 static void smsc_ircc_set_sir_speed(struct smsc_ircc_cb *self, __u32 speed) smsc_ircc_set_sir_speed() argument
1141 IRDA_ASSERT(self != NULL, return;); smsc_ircc_set_sir_speed()
1142 iobase = self->io.sir_base; smsc_ircc_set_sir_speed()
1145 self->io.speed = speed; smsc_ircc_set_sir_speed()
1159 fcr |= self->io.speed < 38400 ? smsc_ircc_set_sir_speed()
1187 struct smsc_ircc_cb *self; smsc_ircc_hard_xmit_fir() local
1193 self = netdev_priv(dev); smsc_ircc_hard_xmit_fir()
1194 IRDA_ASSERT(self != NULL, return NETDEV_TX_OK;); smsc_ircc_hard_xmit_fir()
1198 /* Make sure test of self->io.speed & speed change are atomic */ smsc_ircc_hard_xmit_fir()
1199 spin_lock_irqsave(&self->lock, flags); smsc_ircc_hard_xmit_fir()
1203 if (speed != self->io.speed && speed != -1) { smsc_ircc_hard_xmit_fir()
1209 smsc_ircc_change_speed(self, speed); smsc_ircc_hard_xmit_fir()
1210 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_hard_xmit_fir()
1215 self->new_speed = speed; smsc_ircc_hard_xmit_fir()
1218 skb_copy_from_linear_data(skb, self->tx_buff.head, skb->len); smsc_ircc_hard_xmit_fir()
1220 self->tx_buff.len = skb->len; smsc_ircc_hard_xmit_fir()
1221 self->tx_buff.data = self->tx_buff.head; smsc_ircc_hard_xmit_fir()
1231 bofs = mtt * (self->io.speed / 1000) / 8000; smsc_ircc_hard_xmit_fir()
1235 smsc_ircc_dma_xmit(self, bofs); smsc_ircc_hard_xmit_fir()
1238 smsc_ircc_dma_xmit(self, 0); smsc_ircc_hard_xmit_fir()
1241 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_hard_xmit_fir()
1248 * Function smsc_ircc_dma_xmit (self, bofs)
1253 static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int bofs) smsc_ircc_dma_xmit() argument
1255 int iobase = self->io.fir_base; smsc_ircc_dma_xmit()
1268 self->io.direction = IO_XMIT; smsc_ircc_dma_xmit()
1277 outb(self->tx_buff.len >> 8, iobase + IRCC_TX_SIZE_HI); smsc_ircc_dma_xmit()
1278 outb(self->tx_buff.len & 0xff, iobase + IRCC_TX_SIZE_LO); smsc_ircc_dma_xmit()
1280 /*outb(UART_MCR_OUT2, self->io.sir_base + UART_MCR);*/ smsc_ircc_dma_xmit()
1288 irda_setup_dma(self->io.dma, self->tx_buff_dma, self->tx_buff.len, smsc_ircc_dma_xmit()
1302 * Function smsc_ircc_dma_xmit_complete (self)
1308 static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self) smsc_ircc_dma_xmit_complete() argument
1310 int iobase = self->io.fir_base; smsc_ircc_dma_xmit_complete()
1325 self->netdev->stats.tx_errors++; smsc_ircc_dma_xmit_complete()
1326 self->netdev->stats.tx_fifo_errors++; smsc_ircc_dma_xmit_complete()
1333 self->netdev->stats.tx_packets++; smsc_ircc_dma_xmit_complete()
1334 self->netdev->stats.tx_bytes += self->tx_buff.len; smsc_ircc_dma_xmit_complete()
1338 if (self->new_speed) { smsc_ircc_dma_xmit_complete()
1339 smsc_ircc_change_speed(self, self->new_speed); smsc_ircc_dma_xmit_complete()
1340 self->new_speed = 0; smsc_ircc_dma_xmit_complete()
1343 netif_wake_queue(self->netdev); smsc_ircc_dma_xmit_complete()
1347 * Function smsc_ircc_dma_receive(self)
1353 static int smsc_ircc_dma_receive(struct smsc_ircc_cb *self) smsc_ircc_dma_receive() argument
1355 int iobase = self->io.fir_base; smsc_ircc_dma_receive()
1372 self->io.direction = IO_RECV; smsc_ircc_dma_receive()
1373 self->rx_buff.data = self->rx_buff.head; smsc_ircc_dma_receive()
1381 irda_setup_dma(self->io.dma, self->rx_buff_dma, self->rx_buff.truesize, smsc_ircc_dma_receive()
1403 * Function smsc_ircc_dma_receive_complete(self)
1408 static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self) smsc_ircc_dma_receive_complete() argument
1412 int iobase = self->io.fir_base; smsc_ircc_dma_receive_complete()
1428 get_dma_residue(self->io.dma)); smsc_ircc_dma_receive_complete()
1430 len = self->rx_buff.truesize - get_dma_residue(self->io.dma); smsc_ircc_dma_receive_complete()
1434 self->netdev->stats.rx_errors++; smsc_ircc_dma_receive_complete()
1436 self->netdev->stats.rx_frame_errors++; smsc_ircc_dma_receive_complete()
1438 self->netdev->stats.rx_crc_errors++; smsc_ircc_dma_receive_complete()
1440 self->netdev->stats.rx_length_errors++; smsc_ircc_dma_receive_complete()
1442 self->netdev->stats.rx_length_errors++; smsc_ircc_dma_receive_complete()
1447 len -= self->io.speed < 4000000 ? 2 : 4; smsc_ircc_dma_receive_complete()
1462 memcpy(skb_put(skb, len), self->rx_buff.data, len); smsc_ircc_dma_receive_complete()
1463 self->netdev->stats.rx_packets++; smsc_ircc_dma_receive_complete()
1464 self->netdev->stats.rx_bytes += len; smsc_ircc_dma_receive_complete()
1466 skb->dev = self->netdev; smsc_ircc_dma_receive_complete()
1473 * Function smsc_ircc_sir_receive (self)
1478 static void smsc_ircc_sir_receive(struct smsc_ircc_cb *self) smsc_ircc_sir_receive() argument
1483 IRDA_ASSERT(self != NULL, return;); smsc_ircc_sir_receive()
1485 iobase = self->io.sir_base; smsc_ircc_sir_receive()
1492 async_unwrap_char(self->netdev, &self->netdev->stats, &self->rx_buff, smsc_ircc_sir_receive()
1513 struct smsc_ircc_cb *self = netdev_priv(dev); smsc_ircc_interrupt() local
1518 spin_lock(&self->lock); smsc_ircc_interrupt()
1521 if (self->io.speed <= SMSC_IRCC2_MAX_SIR_SPEED) { smsc_ircc_interrupt()
1526 iobase = self->io.fir_base; smsc_ircc_interrupt()
1542 if (self->io.direction == IO_RECV) smsc_ircc_interrupt()
1543 smsc_ircc_dma_receive_complete(self); smsc_ircc_interrupt()
1545 smsc_ircc_dma_xmit_complete(self); smsc_ircc_interrupt()
1547 smsc_ircc_dma_receive(self); smsc_ircc_interrupt()
1560 spin_unlock(&self->lock); smsc_ircc_interrupt()
1572 struct smsc_ircc_cb *self = netdev_priv(dev); smsc_ircc_interrupt_sir() local
1578 /*spin_lock(&self->lock);*/ smsc_ircc_interrupt_sir()
1580 iobase = self->io.sir_base; smsc_ircc_interrupt_sir()
1598 smsc_ircc_sir_receive(self); smsc_ircc_interrupt_sir()
1603 smsc_ircc_sir_write_wakeup(self); smsc_ircc_interrupt_sir()
1617 /*spin_unlock(&self->lock);*/ smsc_ircc_interrupt_sir()
1624 * Function ircc_is_receiving (self)
1629 static int ircc_is_receiving(struct smsc_ircc_cb *self)
1636 IRDA_ASSERT(self != NULL, return FALSE;);
1639 get_dma_residue(self->io.dma));
1641 status = (self->rx_buff.state != OUTSIDE_FRAME);
1647 static int smsc_ircc_request_irq(struct smsc_ircc_cb *self) smsc_ircc_request_irq() argument
1651 error = request_irq(self->io.irq, smsc_ircc_interrupt, 0, smsc_ircc_request_irq()
1652 self->netdev->name, self->netdev); smsc_ircc_request_irq()
1655 __func__, self->io.irq, error); smsc_ircc_request_irq()
1660 static void smsc_ircc_start_interrupts(struct smsc_ircc_cb *self) smsc_ircc_start_interrupts() argument
1664 spin_lock_irqsave(&self->lock, flags); smsc_ircc_start_interrupts()
1666 self->io.speed = 0; smsc_ircc_start_interrupts()
1667 smsc_ircc_change_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED); smsc_ircc_start_interrupts()
1669 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_start_interrupts()
1672 static void smsc_ircc_stop_interrupts(struct smsc_ircc_cb *self) smsc_ircc_stop_interrupts() argument
1674 int iobase = self->io.fir_base; smsc_ircc_stop_interrupts()
1677 spin_lock_irqsave(&self->lock, flags); smsc_ircc_stop_interrupts()
1684 spin_unlock_irqrestore(&self->lock, flags); smsc_ircc_stop_interrupts()
1696 struct smsc_ircc_cb *self; smsc_ircc_net_open() local
1702 self = netdev_priv(dev); smsc_ircc_net_open()
1703 IRDA_ASSERT(self != NULL, return 0;); smsc_ircc_net_open()
1705 if (self->io.suspended) { smsc_ircc_net_open()
1710 if (request_irq(self->io.irq, smsc_ircc_interrupt, 0, dev->name, smsc_ircc_net_open()
1713 __func__, self->io.irq); smsc_ircc_net_open()
1717 smsc_ircc_start_interrupts(self); smsc_ircc_net_open()
1719 /* Give self a hardware name */ smsc_ircc_net_open()
1721 sprintf(hwname, "SMSC @ 0x%03x", self->io.fir_base); smsc_ircc_net_open()
1727 self->irlap = irlap_open(dev, &self->qos, hwname); smsc_ircc_net_open()
1733 if (request_dma(self->io.dma, dev->name)) { smsc_ircc_net_open()
1737 __func__, self->io.dma); smsc_ircc_net_open()
1754 struct smsc_ircc_cb *self; smsc_ircc_net_close() local
1759 self = netdev_priv(dev); smsc_ircc_net_close()
1760 IRDA_ASSERT(self != NULL, return 0;); smsc_ircc_net_close()
1766 if (self->irlap) smsc_ircc_net_close()
1767 irlap_close(self->irlap); smsc_ircc_net_close()
1768 self->irlap = NULL; smsc_ircc_net_close()
1770 smsc_ircc_stop_interrupts(self); smsc_ircc_net_close()
1773 if (!self->io.suspended) smsc_ircc_net_close()
1774 free_irq(self->io.irq, dev); smsc_ircc_net_close()
1776 disable_dma(self->io.dma); smsc_ircc_net_close()
1777 free_dma(self->io.dma); smsc_ircc_net_close()
1784 struct smsc_ircc_cb *self = platform_get_drvdata(dev); smsc_ircc_suspend() local
1786 if (!self->io.suspended) { smsc_ircc_suspend()
1790 if (netif_running(self->netdev)) { smsc_ircc_suspend()
1791 netif_device_detach(self->netdev); smsc_ircc_suspend()
1792 smsc_ircc_stop_interrupts(self); smsc_ircc_suspend()
1793 free_irq(self->io.irq, self->netdev); smsc_ircc_suspend()
1794 disable_dma(self->io.dma); smsc_ircc_suspend()
1796 self->io.suspended = 1; smsc_ircc_suspend()
1805 struct smsc_ircc_cb *self = platform_get_drvdata(dev); smsc_ircc_resume() local
1807 if (self->io.suspended) { smsc_ircc_resume()
1811 smsc_ircc_init_chip(self); smsc_ircc_resume()
1812 if (netif_running(self->netdev)) { smsc_ircc_resume()
1813 if (smsc_ircc_request_irq(self)) { smsc_ircc_resume()
1818 unregister_netdevice(self->netdev); smsc_ircc_resume()
1820 enable_dma(self->io.dma); smsc_ircc_resume()
1821 smsc_ircc_start_interrupts(self); smsc_ircc_resume()
1822 netif_device_attach(self->netdev); smsc_ircc_resume()
1825 self->io.suspended = 0; smsc_ircc_resume()
1832 * Function smsc_ircc_close (self)
1837 static int __exit smsc_ircc_close(struct smsc_ircc_cb *self) smsc_ircc_close() argument
1841 IRDA_ASSERT(self != NULL, return -1;); smsc_ircc_close()
1843 platform_device_unregister(self->pldev); smsc_ircc_close()
1846 unregister_netdev(self->netdev); smsc_ircc_close()
1848 smsc_ircc_stop_interrupts(self); smsc_ircc_close()
1852 self->io.fir_base); smsc_ircc_close()
1854 release_region(self->io.fir_base, self->io.fir_ext); smsc_ircc_close()
1857 self->io.sir_base); smsc_ircc_close()
1859 release_region(self->io.sir_base, self->io.sir_ext); smsc_ircc_close()
1861 if (self->tx_buff.head) smsc_ircc_close()
1862 dma_free_coherent(NULL, self->tx_buff.truesize, smsc_ircc_close()
1863 self->tx_buff.head, self->tx_buff_dma); smsc_ircc_close()
1865 if (self->rx_buff.head) smsc_ircc_close()
1866 dma_free_coherent(NULL, self->rx_buff.truesize, smsc_ircc_close()
1867 self->rx_buff.head, self->rx_buff_dma); smsc_ircc_close()
1869 free_netdev(self->netdev); smsc_ircc_close()
1897 static void smsc_ircc_sir_start(struct smsc_ircc_cb *self) smsc_ircc_sir_start() argument
1904 IRDA_ASSERT(self != NULL, return;); smsc_ircc_sir_start()
1905 dev = self->netdev; smsc_ircc_sir_start()
1908 fir_base = self->io.fir_base; smsc_ircc_sir_start()
1909 sir_base = self->io.sir_base; smsc_ircc_sir_start()
1915 /*smsc_ircc_sir_stop(self);*/ smsc_ircc_sir_start()
1934 void smsc_ircc_sir_stop(struct smsc_ircc_cb *self) smsc_ircc_sir_stop() argument
1939 iobase = self->io.sir_base; smsc_ircc_sir_stop()
1950 * Function smsc_sir_write_wakeup (self)
1956 static void smsc_ircc_sir_write_wakeup(struct smsc_ircc_cb *self) smsc_ircc_sir_write_wakeup() argument
1962 IRDA_ASSERT(self != NULL, return;); smsc_ircc_sir_write_wakeup()
1966 iobase = self->io.sir_base; smsc_ircc_sir_write_wakeup()
1969 if (self->tx_buff.len > 0) { smsc_ircc_sir_write_wakeup()
1971 actual = smsc_ircc_sir_write(iobase, self->io.fifo_size, smsc_ircc_sir_write_wakeup()
1972 self->tx_buff.data, self->tx_buff.len); smsc_ircc_sir_write_wakeup()
1973 self->tx_buff.data += actual; smsc_ircc_sir_write_wakeup()
1974 self->tx_buff.len -= actual; smsc_ircc_sir_write_wakeup()
1977 /*if (self->tx_buff.len ==0) {*/ smsc_ircc_sir_write_wakeup()
1984 if (self->new_speed) { smsc_ircc_sir_write_wakeup()
1986 __func__, self->new_speed); smsc_ircc_sir_write_wakeup()
1987 smsc_ircc_sir_wait_hw_transmitter_finish(self); smsc_ircc_sir_write_wakeup()
1988 smsc_ircc_change_speed(self, self->new_speed); smsc_ircc_sir_write_wakeup()
1989 self->new_speed = 0; smsc_ircc_sir_write_wakeup()
1992 netif_wake_queue(self->netdev); smsc_ircc_sir_write_wakeup()
1994 self->netdev->stats.tx_packets++; smsc_ircc_sir_write_wakeup()
1996 if (self->io.speed <= 115200) { smsc_ircc_sir_write_wakeup()
2002 fcr |= self->io.speed < 38400 ? smsc_ircc_sir_write_wakeup()
2040 * Function smsc_ircc_is_receiving (self)
2045 static int smsc_ircc_is_receiving(struct smsc_ircc_cb *self) smsc_ircc_is_receiving() argument
2047 return self->rx_buff.state != OUTSIDE_FRAME; smsc_ircc_is_receiving()
2052 * Function smsc_ircc_probe_transceiver(self)
2057 static void smsc_ircc_probe_transceiver(struct smsc_ircc_cb *self) smsc_ircc_probe_transceiver() argument
2061 IRDA_ASSERT(self != NULL, return;); smsc_ircc_probe_transceiver()
2064 if (smsc_transceivers[i].probe(self->io.fir_base)) { smsc_ircc_probe_transceiver()
2067 self->transceiver= i + 1; smsc_ircc_probe_transceiver()
2074 self->transceiver = SMSC_IRCC2_C_DEFAULT_TRANSCEIVER; smsc_ircc_probe_transceiver()
2079 * Function smsc_ircc_set_transceiver_for_speed(self, speed)
2084 static void smsc_ircc_set_transceiver_for_speed(struct smsc_ircc_cb *self, u32 speed) smsc_ircc_set_transceiver_for_speed() argument
2088 trx = self->transceiver; smsc_ircc_set_transceiver_for_speed()
2090 smsc_transceivers[trx - 1].set_for_speed(self->io.fir_base, speed); smsc_ircc_set_transceiver_for_speed()
2116 static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self) smsc_ircc_sir_wait_hw_transmitter_finish() argument
2118 int iobase = self->io.sir_base; smsc_ircc_sir_wait_hw_transmitter_finish()
2949 * Function smsc_ircc_set_transceiver_smsc_ircc_fast_pin_select(self, speed)
|
| H A D | sir-dev.h | 110 int sirdev_put_instance(struct sir_dev *self);
123 int sirdev_get_dongle(struct sir_dev *self, IRDA_DONGLE type);
124 int sirdev_put_dongle(struct sir_dev *self);
|
| /linux-4.1.27/drivers/net/wireless/cw1200/ |
| H A D | cw1200_sdio.c | 68 static int cw1200_sdio_memcpy_fromio(struct hwbus_priv *self, cw1200_sdio_memcpy_fromio() argument
72 return sdio_memcpy_fromio(self->func, dst, addr, count); cw1200_sdio_memcpy_fromio()
75 static int cw1200_sdio_memcpy_toio(struct hwbus_priv *self, cw1200_sdio_memcpy_toio() argument
79 return sdio_memcpy_toio(self->func, addr, (void *)src, count); cw1200_sdio_memcpy_toio()
82 static void cw1200_sdio_lock(struct hwbus_priv *self) cw1200_sdio_lock() argument
84 sdio_claim_host(self->func); cw1200_sdio_lock()
87 static void cw1200_sdio_unlock(struct hwbus_priv *self) cw1200_sdio_unlock() argument
89 sdio_release_host(self->func); cw1200_sdio_unlock()
94 struct hwbus_priv *self = sdio_get_drvdata(func); cw1200_sdio_irq_handler() local
97 if (self->core) cw1200_sdio_irq_handler()
98 cw1200_irq_handler(self->core); cw1200_sdio_irq_handler()
108 struct hwbus_priv *self = dev_id; cw1200_gpio_irq() local
110 if (self->core) { cw1200_gpio_irq()
111 cw1200_sdio_lock(self); cw1200_gpio_irq()
112 cw1200_irq_handler(self->core); cw1200_gpio_irq()
113 cw1200_sdio_unlock(self); cw1200_gpio_irq()
120 static int cw1200_request_irq(struct hwbus_priv *self) cw1200_request_irq() argument
125 cccr = sdio_f0_readb(self->func, SDIO_CCCR_IENx, &ret); cw1200_request_irq()
133 cccr |= BIT(self->func->num); cw1200_request_irq()
135 sdio_f0_writeb(self->func, cccr, SDIO_CCCR_IENx, &ret); cw1200_request_irq()
139 ret = enable_irq_wake(self->pdata->irq); cw1200_request_irq()
144 ret = request_threaded_irq(self->pdata->irq, cw1200_gpio_hardirq, cw1200_request_irq()
147 "cw1200_wlan_irq", self); cw1200_request_irq()
157 static int cw1200_sdio_irq_subscribe(struct hwbus_priv *self) cw1200_sdio_irq_subscribe() argument
162 sdio_claim_host(self->func); cw1200_sdio_irq_subscribe()
163 if (self->pdata->irq) cw1200_sdio_irq_subscribe()
164 ret = cw1200_request_irq(self); cw1200_sdio_irq_subscribe()
166 ret = sdio_claim_irq(self->func, cw1200_sdio_irq_handler); cw1200_sdio_irq_subscribe()
168 sdio_release_host(self->func); cw1200_sdio_irq_subscribe()
172 static int cw1200_sdio_irq_unsubscribe(struct hwbus_priv *self) cw1200_sdio_irq_unsubscribe() argument
178 if (self->pdata->irq) { cw1200_sdio_irq_unsubscribe()
179 disable_irq_wake(self->pdata->irq); cw1200_sdio_irq_unsubscribe()
180 free_irq(self->pdata->irq, self); cw1200_sdio_irq_unsubscribe()
182 sdio_claim_host(self->func); cw1200_sdio_irq_unsubscribe()
183 ret = sdio_release_irq(self->func); cw1200_sdio_irq_unsubscribe()
184 sdio_release_host(self->func); cw1200_sdio_irq_unsubscribe()
249 static size_t cw1200_sdio_align_size(struct hwbus_priv *self, size_t size) cw1200_sdio_align_size() argument
251 if (self->pdata->no_nptb) cw1200_sdio_align_size()
254 size = sdio_align_size(self->func, size); cw1200_sdio_align_size()
259 static int cw1200_sdio_pm(struct hwbus_priv *self, bool suspend) cw1200_sdio_pm() argument
263 if (self->pdata->irq) cw1200_sdio_pm()
264 ret = irq_set_irq_wake(self->pdata->irq, suspend); cw1200_sdio_pm()
281 struct hwbus_priv *self; cw1200_sdio_probe() local
290 self = kzalloc(sizeof(*self), GFP_KERNEL); cw1200_sdio_probe()
291 if (!self) { cw1200_sdio_probe()
298 self->pdata = global_plat_data; /* FIXME */ cw1200_sdio_probe()
299 self->func = func; cw1200_sdio_probe()
300 sdio_set_drvdata(func, self); cw1200_sdio_probe()
305 status = cw1200_sdio_irq_subscribe(self); cw1200_sdio_probe()
308 self, &func->dev, &self->core, cw1200_sdio_probe()
309 self->pdata->ref_clk, cw1200_sdio_probe()
310 self->pdata->macaddr, cw1200_sdio_probe()
311 self->pdata->sdd_file, cw1200_sdio_probe()
312 self->pdata->have_5ghz); cw1200_sdio_probe()
314 cw1200_sdio_irq_unsubscribe(self); cw1200_sdio_probe()
319 kfree(self); cw1200_sdio_probe()
330 struct hwbus_priv *self = sdio_get_drvdata(func); cw1200_sdio_disconnect() local
332 if (self) { cw1200_sdio_disconnect()
333 cw1200_sdio_irq_unsubscribe(self); cw1200_sdio_disconnect()
334 if (self->core) { cw1200_sdio_disconnect()
335 cw1200_core_release(self->core); cw1200_sdio_disconnect()
336 self->core = NULL; cw1200_sdio_disconnect()
342 kfree(self); cw1200_sdio_disconnect()
351 struct hwbus_priv *self = sdio_get_drvdata(func); cw1200_sdio_suspend() local
353 if (!cw1200_can_suspend(self->core)) cw1200_sdio_suspend()
|
| H A D | cw1200_spi.c | 60 static int cw1200_spi_memcpy_fromio(struct hwbus_priv *self, cw1200_spi_memcpy_fromio() argument
92 if (self->func->bits_per_word == 8) cw1200_spi_memcpy_fromio()
99 ret = spi_sync(self->func, &m); cw1200_spi_memcpy_fromio()
115 if (self->func->bits_per_word == 8) cw1200_spi_memcpy_fromio()
126 static int cw1200_spi_memcpy_toio(struct hwbus_priv *self, cw1200_spi_memcpy_toio() argument
157 if (self->func->bits_per_word == 8) cw1200_spi_memcpy_toio()
179 rval = spi_sync(self->func, &m); cw1200_spi_memcpy_toio()
187 if (self->func->bits_per_word == 8) cw1200_spi_memcpy_toio()
197 static void cw1200_spi_lock(struct hwbus_priv *self) cw1200_spi_lock() argument
205 add_wait_queue(&self->wq, &wait); cw1200_spi_lock()
206 spin_lock_irqsave(&self->lock, flags); cw1200_spi_lock()
209 if (!self->claimed) cw1200_spi_lock()
211 spin_unlock_irqrestore(&self->lock, flags); cw1200_spi_lock()
213 spin_lock_irqsave(&self->lock, flags); cw1200_spi_lock()
216 self->claimed = 1; cw1200_spi_lock()
217 spin_unlock_irqrestore(&self->lock, flags); cw1200_spi_lock()
218 remove_wait_queue(&self->wq, &wait); cw1200_spi_lock()
223 static void cw1200_spi_unlock(struct hwbus_priv *self) cw1200_spi_unlock() argument
227 spin_lock_irqsave(&self->lock, flags); cw1200_spi_unlock()
228 self->claimed = 0; cw1200_spi_unlock()
229 spin_unlock_irqrestore(&self->lock, flags); cw1200_spi_unlock()
230 wake_up(&self->wq); cw1200_spi_unlock()
237 struct hwbus_priv *self = dev_id; cw1200_spi_irq_handler() local
239 if (self->core) { cw1200_spi_irq_handler()
240 cw1200_spi_lock(self); cw1200_spi_irq_handler()
241 cw1200_irq_handler(self->core); cw1200_spi_irq_handler()
242 cw1200_spi_unlock(self); cw1200_spi_irq_handler()
249 static int cw1200_spi_irq_subscribe(struct hwbus_priv *self) cw1200_spi_irq_subscribe() argument
255 ret = request_threaded_irq(self->func->irq, NULL, cw1200_spi_irq_subscribe()
258 "cw1200_wlan_irq", self); cw1200_spi_irq_subscribe()
262 ret = enable_irq_wake(self->func->irq); cw1200_spi_irq_subscribe()
269 free_irq(self->func->irq, self); cw1200_spi_irq_subscribe()
274 static int cw1200_spi_irq_unsubscribe(struct hwbus_priv *self) cw1200_spi_irq_unsubscribe() argument
279 disable_irq_wake(self->func->irq); cw1200_spi_irq_unsubscribe()
280 free_irq(self->func->irq, self); cw1200_spi_irq_unsubscribe()
345 static size_t cw1200_spi_align_size(struct hwbus_priv *self, size_t size) cw1200_spi_align_size() argument
350 static int cw1200_spi_pm(struct hwbus_priv *self, bool suspend) cw1200_spi_pm() argument
352 return irq_set_irq_wake(self->func->irq, suspend); cw1200_spi_pm()
369 struct hwbus_priv *self; cw1200_spi_probe() local
401 self = devm_kzalloc(&func->dev, sizeof(*self), GFP_KERNEL); cw1200_spi_probe()
402 if (!self) { cw1200_spi_probe()
407 self->pdata = plat_data; cw1200_spi_probe()
408 self->func = func; cw1200_spi_probe()
409 spin_lock_init(&self->lock); cw1200_spi_probe()
411 spi_set_drvdata(func, self); cw1200_spi_probe()
413 init_waitqueue_head(&self->wq); cw1200_spi_probe()
415 status = cw1200_spi_irq_subscribe(self); cw1200_spi_probe()
418 self, &func->dev, &self->core, cw1200_spi_probe()
419 self->pdata->ref_clk, cw1200_spi_probe()
420 self->pdata->macaddr, cw1200_spi_probe()
421 self->pdata->sdd_file, cw1200_spi_probe()
422 self->pdata->have_5ghz); cw1200_spi_probe()
425 cw1200_spi_irq_unsubscribe(self); cw1200_spi_probe()
435 struct hwbus_priv *self = spi_get_drvdata(func); cw1200_spi_disconnect() local
437 if (self) { cw1200_spi_disconnect()
438 cw1200_spi_irq_unsubscribe(self); cw1200_spi_disconnect()
439 if (self->core) { cw1200_spi_disconnect()
440 cw1200_core_release(self->core); cw1200_spi_disconnect()
441 self->core = NULL; cw1200_spi_disconnect()
452 struct hwbus_priv *self = spi_get_drvdata(to_spi_device(dev)); cw1200_spi_suspend() local
454 if (!cw1200_can_suspend(self->core)) cw1200_spi_suspend()
|
| H A D | hwbus.h | 23 int (*hwbus_memcpy_fromio)(struct hwbus_priv *self, unsigned int addr,
25 int (*hwbus_memcpy_toio)(struct hwbus_priv *self, unsigned int addr,
27 void (*lock)(struct hwbus_priv *self);
28 void (*unlock)(struct hwbus_priv *self);
29 size_t (*align_size)(struct hwbus_priv *self, size_t size);
30 int (*power_mgmt)(struct hwbus_priv *self, bool suspend);
|
| H A D | main.c | 589 void cw1200_core_release(struct cw1200_common *self) cw1200_core_release() argument
592 self->hwbus_ops->lock(self->hwbus_priv); cw1200_core_release()
593 __cw1200_irq_enable(self, 0); cw1200_core_release()
594 self->hwbus_ops->unlock(self->hwbus_priv); cw1200_core_release()
597 cw1200_unregister_common(self->hw); cw1200_core_release()
598 cw1200_free_common(self->hw); cw1200_core_release()
|
| /linux-4.1.27/tools/perf/tests/ |
| H A D | attr.py | 13 def __init__(self, test, msg):
14 self.msg = msg
15 self.test = test
16 def getMsg(self):
17 return '\'%s\' - %s' % (self.test.path, self.msg)
20 def __init__(self, test):
21 self.test = test
22 def getMsg(self):
23 return '\'%s\'' % self.test.path
66 def add(self, data):
69 self[key] = val
71 def __init__(self, name, data, base):
73 self.name = name;
74 self.group = ''
75 self.add(base)
76 self.add(data)
78 def compare_data(self, a, b):
92 def equal(self, other):
94 log.debug(" [%s] %s %s" % (t, self[t], other[t]));
95 if not self.has_key(t) or not other.has_key(t):
97 if not self.compare_data(self[t], other[t]):
101 def diff(self, other):
103 if not self.has_key(t) or not other.has_key(t):
105 if not self.compare_data(self[t], other[t]):
106 log.warning("expected %s=%s, got %s" % (t, self[t], other[t]))
120 def __init__(self, path, options):
126 self.path = path
127 self.test_dir = options.test_dir
128 self.perf = options.perf
129 self.command = parser.get('config', 'command')
130 self.args = parser.get('config', 'args')
133 self.ret = parser.get('config', 'ret')
135 self.ret = 0
137 self.expect = {}
138 self.result = {}
140 self.load_events(path, self.expect)
142 def is_event(self, name):
148 def load_events(self, path, events):
155 for section in filter(self.is_event, parser_event.sections()):
164 parser_base.read(self.test_dir + '/' + base)
170 def run_cmd(self, tempdir):
172 self.perf, self.command, tempdir, self.args)
177 if ret != int(self.ret):
178 raise Unsup(self)
180 def compare(self, expect, result):
203 raise Fail(self, 'match failure');
218 raise Fail(self, 'group failure')
225 def resolve_groups(self, events):
237 def run(self):
242 self.run_cmd(tempdir);
247 self.load_events(f, self.result);
250 self.resolve_groups(self.expect);
251 self.resolve_groups(self.result);
254 self.compare(self.expect, self.result)
255 self.compare(self.result, self.expect)
|
| /linux-4.1.27/scripts/gdb/linux/ |
| H A D | symbols.py | 24 def __init__(self, spec, gdb_command):
25 super(LoadModuleBreakpoint, self).__init__(spec, internal=True)
26 self.silent = True
27 self.gdb_command = gdb_command
29 def stop(self):
32 cmd = self.gdb_command
71 def __init__(self):
72 super(LxSymbols, self).__init__("lx-symbols", gdb.COMMAND_FILES,
75 def _update_module_files(self):
76 self.module_files = []
77 for path in self.module_paths:
82 self.module_files.append(root + "/" + name)
83 self.module_files_updated = True
85 def _get_module_file(self, module_name):
88 for name in self.module_files:
93 def _section_arguments(self, module):
110 def load_module_symbols(self, module):
114 module_file = self._get_module_file(module_name)
115 if not module_file and not self.module_files_updated:
116 self._update_module_files()
117 module_file = self._get_module_file(module_name)
125 sections=self._section_arguments(module))
127 if not module_name in self.loaded_modules:
128 self.loaded_modules.append(module_name)
132 def load_all_symbols(self):
146 self.loaded_modules = []
151 [self.load_module_symbols(module) for module in module_list]
156 def invoke(self, arg, from_tty):
157 self.module_paths = arg.split()
158 self.module_paths.append(os.getcwd())
161 self.module_files = []
162 self.module_files_updated = False
164 self.load_all_symbols()
167 if not self.breakpoint is None:
168 self.breakpoint.delete()
169 self.breakpoint = None
170 self.breakpoint = LoadModuleBreakpoint(
171 "kernel/module.c:do_init_module", self)
|
| H A D | utils.py | 18 def __init__(self, name):
19 self._type = None
20 self._name = name
22 def _new_objfile_handler(self, event):
23 self._type = None
24 gdb.events.new_objfile.disconnect(self._new_objfile_handler)
26 def get_type(self):
27 if self._type is None:
28 self._type = gdb.lookup_type(self._name)
29 if self._type is None:
31 "cannot resolve type '{0}'".format(self._name))
33 gdb.events.new_objfile.connect(self._new_objfile_handler)
34 return self._type
62 def __init__(self):
63 super(ContainerOf, self).__init__("container_of")
65 def invoke(self, ptr, typename, elementname):
|
| H A D | tasks.py | 54 def __init__(self):
55 super(LxTaskByPidFunc, self).__init__("lx_task_by_pid")
57 def invoke(self, pid):
93 def __init__(self):
94 super(LxThreadInfoFunc, self).__init__("lx_thread_info")
96 def invoke(self, task):
|
| H A D | modules.py | 47 def __init__(self):
48 super(LxModule, self).__init__("lx_module")
50 def invoke(self, mod_name):
67 def __init__(self):
68 super(LxLsmod, self).__init__("lx-lsmod", gdb.COMMAND_DATA)
70 def invoke(self, arg, from_tty):
83 t = self._module_use_type.get_type().pointer()
|
| H A D | cpus.py | 110 def __init__(self):
111 super(PerCpu, self).__init__("lx_per_cpu")
113 def invoke(self, var_name, cpu=-1):
127 def __init__(self):
128 super(LxCurrentFunc, self).__init__("lx_current")
130 def invoke(self, cpu=-1):
|
| H A D | dmesg.py | 23 def __init__(self):
24 super(LxDmesg, self).__init__("lx-dmesg", gdb.COMMAND_DATA)
26 def invoke(self, arg, from_tty):
|
| /linux-4.1.27/fs/proc/ |
| H A D | self.c | 8 * /proc/self:
51 struct dentry *self; proc_setup_self() local
54 self = d_alloc_name(s->s_root, "self"); proc_setup_self()
55 if (self) { proc_setup_self()
64 d_add(self, inode); proc_setup_self()
66 dput(self); proc_setup_self()
67 self = ERR_PTR(-ENOMEM); proc_setup_self()
70 self = ERR_PTR(-ENOMEM); proc_setup_self()
73 if (IS_ERR(self)) { proc_setup_self()
74 pr_err("proc_fill_super: can't allocate /proc/self\n"); proc_setup_self()
75 return PTR_ERR(self); proc_setup_self()
77 ns->proc_self = self; proc_setup_self()
|
| H A D | Makefile | 25 proc-y += self.o
|
| H A D | thread_self.c | 55 thread_self = d_alloc_name(s->s_root, "thread-self"); proc_setup_thread_self()
|
| /linux-4.1.27/scripts/kconfig/ |
| H A D | kxgettext.c | 71 struct file_line *self = malloc(sizeof(*self)); file_line__new() local
73 if (self == NULL) file_line__new()
76 self->file = file; file_line__new()
77 self->lineno = lineno; file_line__new()
78 self->next = NULL; file_line__new()
80 return self; file_line__new()
95 struct message *self = malloc(sizeof(*self)); message__new() local
97 if (self == NULL) message__new()
100 self->files = file_line__new(file, lineno); message__new()
101 if (self->files == NULL) message__new()
104 self->msg = strdup(msg); message__new()
105 if (self->msg == NULL) message__new()
108 self->option = option; message__new()
109 self->next = NULL; message__new()
111 return self; message__new()
113 free(self->files); message__new()
115 free(self); message__new()
116 self = NULL; message__new()
133 static int message__add_file_line(struct message *self, const char *file, message__add_file_line() argument
142 fl->next = self->files; message__add_file_line()
143 self->files = fl; message__add_file_line()
189 static void message__print_file_lineno(struct message *self) message__print_file_lineno() argument
191 struct file_line *fl = self->files; message__print_file_lineno()
194 if (self->option != NULL) message__print_file_lineno()
195 printf("# %s:00000\n", self->option); message__print_file_lineno()
208 static void message__print_gettext_msgid_msgstr(struct message *self) message__print_gettext_msgid_msgstr() argument
210 message__print_file_lineno(self); message__print_gettext_msgid_msgstr()
213 "msgstr \"\"\n", self->msg); message__print_gettext_msgid_msgstr()
|
| /linux-4.1.27/net/irda/irnet/ |
| H A D | irnet_irda.c | 23 irnet_socket * self = irnet_ppp_disconnect() local
26 if (self == NULL) irnet_ppp_disconnect()
32 if (self->ppp_open && !self->ttp_open && !self->ttp_connect) { irnet_ppp_disconnect()
33 ppp_unregister_channel(&self->chan); irnet_ppp_disconnect()
34 self->ppp_open = 0; irnet_ppp_disconnect()
110 * because our input structure (self) is quite different
117 * Function irda_open_tsap (self)
124 irnet_open_tsap(irnet_socket * self) irnet_open_tsap() argument
128 DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self); irnet_open_tsap()
130 DABORT(self->tsap != NULL, -EBUSY, IRDA_SR_ERROR, "Already busy !\n"); irnet_open_tsap()
141 notify.instance = self; irnet_open_tsap()
145 self->tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, irnet_open_tsap()
147 DABORT(self->tsap == NULL, -ENOMEM, irnet_open_tsap()
151 self->stsap_sel = self->tsap->stsap_sel; irnet_open_tsap()
154 self->tsap, self->stsap_sel); irnet_open_tsap()
160 * Function irnet_ias_to_tsap (self, result, value)
169 * The failure is in self->errno
173 irnet_ias_to_tsap(irnet_socket * self, irnet_ias_to_tsap() argument
179 DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self); irnet_ias_to_tsap()
182 self->errno = 0; irnet_ias_to_tsap()
191 self->errno = -EADDRNOTAVAIL; irnet_ias_to_tsap()
197 self->errno = -EHOSTUNREACH; irnet_ias_to_tsap()
217 self->errno = -EADDRNOTAVAIL; irnet_ias_to_tsap()
220 self->errno = -EADDRNOTAVAIL; irnet_ias_to_tsap()
231 if(!(self->errno)) irnet_ias_to_tsap()
235 self->errno = -EHOSTUNREACH; irnet_ias_to_tsap()
246 * Function irnet_find_lsap_sel (self)
257 irnet_find_lsap_sel(irnet_socket * self) irnet_find_lsap_sel() argument
259 DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self); irnet_find_lsap_sel()
262 DABORT(self->iriap, -EBUSY, IRDA_SR_ERROR, "busy with a previous query.\n"); irnet_find_lsap_sel()
265 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, irnet_find_lsap_sel()
269 self->errno = -EHOSTUNREACH; irnet_find_lsap_sel()
272 iriap_getvaluebyclass_request(self->iriap, self->rsaddr, self->daddr, irnet_find_lsap_sel()
286 * Function irnet_connect_tsap (self)
292 irnet_connect_tsap(irnet_socket * self) irnet_connect_tsap() argument
296 DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self); irnet_connect_tsap()
299 err = irnet_open_tsap(self); irnet_connect_tsap()
302 clear_bit(0, &self->ttp_connect); irnet_connect_tsap()
308 err = irttp_connect_request(self->tsap, self->dtsap_sel, irnet_connect_tsap()
309 self->rsaddr, self->daddr, NULL, irnet_connect_tsap()
310 self->max_sdu_size_rx, NULL); irnet_connect_tsap()
313 clear_bit(0, &self->ttp_connect); irnet_connect_tsap()
329 * Function irnet_discover_next_daddr (self)
336 irnet_discover_next_daddr(irnet_socket * self) irnet_discover_next_daddr() argument
340 if(self->iriap) irnet_discover_next_daddr()
342 iriap_close(self->iriap); irnet_discover_next_daddr()
343 self->iriap = NULL; irnet_discover_next_daddr()
346 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self, irnet_discover_next_daddr()
348 if(self->iriap == NULL) irnet_discover_next_daddr()
352 self->disco_index++; irnet_discover_next_daddr()
355 if(self->disco_index < self->disco_number) irnet_discover_next_daddr()
358 iriap_getvaluebyclass_request(self->iriap, irnet_discover_next_daddr()
359 self->discoveries[self->disco_index].saddr, irnet_discover_next_daddr()
360 self->discoveries[self->disco_index].daddr, irnet_discover_next_daddr()
373 * Function irnet_discover_daddr_and_lsap_sel (self)
395 irnet_discover_daddr_and_lsap_sel(irnet_socket * self) irnet_discover_daddr_and_lsap_sel() argument
399 DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self); irnet_discover_daddr_and_lsap_sel()
402 self->discoveries = irlmp_get_discoveries(&self->disco_number, self->mask, irnet_discover_daddr_and_lsap_sel()
406 if(self->discoveries == NULL) irnet_discover_daddr_and_lsap_sel()
408 self->disco_number = -1; irnet_discover_daddr_and_lsap_sel()
409 clear_bit(0, &self->ttp_connect); irnet_discover_daddr_and_lsap_sel()
413 self->discoveries, self->disco_number); irnet_discover_daddr_and_lsap_sel()
416 self->disco_index = -1; irnet_discover_daddr_and_lsap_sel()
417 self->daddr = DEV_ADDR_ANY; irnet_discover_daddr_and_lsap_sel()
420 ret = irnet_discover_next_daddr(self); irnet_discover_daddr_and_lsap_sel()
424 if(self->iriap) irnet_discover_daddr_and_lsap_sel()
425 iriap_close(self->iriap); irnet_discover_daddr_and_lsap_sel()
426 self->iriap = NULL; irnet_discover_daddr_and_lsap_sel()
429 kfree(self->discoveries); irnet_discover_daddr_and_lsap_sel()
430 self->discoveries = NULL; irnet_discover_daddr_and_lsap_sel()
432 clear_bit(0, &self->ttp_connect); irnet_discover_daddr_and_lsap_sel()
444 * Function irnet_dname_to_daddr (self)
451 irnet_dname_to_daddr(irnet_socket * self) irnet_dname_to_daddr() argument
457 DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self); irnet_dname_to_daddr()
474 if(!strncmp(discoveries[i].info, self->rname, NICKNAME_MAX_LEN)) irnet_dname_to_daddr()
477 self->daddr = discoveries[i].daddr; irnet_dname_to_daddr()
479 self->rname, self->daddr); irnet_dname_to_daddr()
486 DEBUG(IRDA_SR_INFO, "cannot discover device ``%s'' !!!\n", self->rname); irnet_dname_to_daddr()
503 irda_irnet_create(irnet_socket * self) irda_irnet_create() argument
505 DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self); irda_irnet_create()
507 self->magic = IRNET_MAGIC; /* Paranoia */ irda_irnet_create()
509 self->ttp_open = 0; /* Prevent higher layer from accessing IrTTP */ irda_irnet_create()
510 self->ttp_connect = 0; /* Not connecting yet */ irda_irnet_create()
511 self->rname[0] = '\0'; /* May be set via control channel */ irda_irnet_create()
512 self->rdaddr = DEV_ADDR_ANY; /* May be set via control channel */ irda_irnet_create()
513 self->rsaddr = DEV_ADDR_ANY; /* May be set via control channel */ irda_irnet_create()
514 self->daddr = DEV_ADDR_ANY; /* Until we get connected */ irda_irnet_create()
515 self->saddr = DEV_ADDR_ANY; /* Until we get connected */ irda_irnet_create()
516 self->max_sdu_size_rx = TTP_SAR_UNBOUND; irda_irnet_create()
519 self->ckey = irlmp_register_client(0, NULL, NULL, NULL); irda_irnet_create()
521 self->mask = 0xffff; /* For W2k compatibility */ irda_irnet_create()
523 self->mask = irlmp_service_to_hint(S_LAN); irda_irnet_create()
525 self->tx_flow = FLOW_START; /* Flow control from IrTTP */ irda_irnet_create()
527 INIT_WORK(&self->disconnect_work, irnet_ppp_disconnect); irda_irnet_create()
547 irda_irnet_connect(irnet_socket * self) irda_irnet_connect() argument
551 DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self); irda_irnet_connect()
557 if(test_and_set_bit(0, &self->ttp_connect)) irda_irnet_connect()
559 if((self->iriap != NULL) || (self->tsap != NULL)) irda_irnet_connect()
566 if((irnet_server.running) && (self->q.q_next == NULL)) irda_irnet_connect()
569 hashbin_insert(irnet_server.list, (irda_queue_t *) self, 0, self->rname); irda_irnet_connect()
571 DEBUG(IRDA_SOCK_INFO, "Inserted ``%s'' in hashbin...\n", self->rname); irda_irnet_connect()
575 if((self->rdaddr == DEV_ADDR_ANY) && (self->rname[0] == '\0')) irda_irnet_connect()
578 if((err = irnet_discover_daddr_and_lsap_sel(self)) != 0) irda_irnet_connect()
585 if(self->rdaddr == DEV_ADDR_ANY) irda_irnet_connect()
587 if((err = irnet_dname_to_daddr(self)) != 0) irda_irnet_connect()
592 self->daddr = self->rdaddr; irda_irnet_connect()
595 irnet_find_lsap_sel(self); irda_irnet_connect()
609 * Function irda_irnet_destroy(self)
616 irda_irnet_destroy(irnet_socket * self) irda_irnet_destroy() argument
618 DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self); irda_irnet_destroy()
619 if(self == NULL) irda_irnet_destroy()
624 if((irnet_server.running) && (self->q.q_next != NULL)) irda_irnet_destroy()
629 entry = hashbin_remove_this(irnet_server.list, (irda_queue_t *) self); irda_irnet_destroy()
630 self->q.q_next = NULL; irda_irnet_destroy()
632 DASSERT(entry == self, , IRDA_SOCK_ERROR, "Can't remove from hash.\n"); irda_irnet_destroy()
636 if(test_bit(0, &self->ttp_open)) irda_irnet_destroy()
642 self->saddr, self->daddr, self->rname, 0); irda_irnet_destroy()
647 clear_bit(0, &self->ttp_connect); irda_irnet_destroy()
650 clear_bit(0, &self->ttp_open); irda_irnet_destroy()
653 irlmp_unregister_client(self->ckey); irda_irnet_destroy()
656 if(self->iriap) irda_irnet_destroy()
658 iriap_close(self->iriap); irda_irnet_destroy()
659 self->iriap = NULL; irda_irnet_destroy()
663 if(self->discoveries != NULL) irda_irnet_destroy()
666 kfree(self->discoveries); irda_irnet_destroy()
667 self->discoveries = NULL; irda_irnet_destroy()
671 if(self->tsap) irda_irnet_destroy()
674 irttp_disconnect_request(self->tsap, NULL, P_NORMAL); irda_irnet_destroy()
675 irttp_close_tsap(self->tsap); irda_irnet_destroy()
676 self->tsap = NULL; irda_irnet_destroy()
678 self->stsap_sel = 0; irda_irnet_destroy()
695 * Function irnet_daddr_to_dname (self)
702 irnet_daddr_to_dname(irnet_socket * self) irnet_daddr_to_dname() argument
708 DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self); irnet_daddr_to_dname()
721 if(discoveries[i].daddr == self->daddr) irnet_daddr_to_dname()
724 strlcpy(self->rname, discoveries[i].info, sizeof(self->rname)); irnet_daddr_to_dname()
725 self->rname[sizeof(self->rname) - 1] = '\0'; irnet_daddr_to_dname()
727 self->daddr, self->rname); irnet_daddr_to_dname()
734 DEXIT(IRDA_SERV_INFO, ": cannot discover device 0x%08x !!!\n", self->daddr); irnet_daddr_to_dname()
741 * Function irda_find_socket (self)
749 irnet_find_socket(irnet_socket * self) irnet_find_socket() argument
754 DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self); irnet_find_socket()
757 self->daddr = irttp_get_daddr(self->tsap); irnet_find_socket()
758 self->saddr = irttp_get_saddr(self->tsap); irnet_find_socket()
761 err = irnet_daddr_to_dname(self); irnet_find_socket()
771 0, self->rname); irnet_find_socket()
787 if((new->rdaddr == self->daddr) || (new->daddr == self->daddr)) irnet_find_socket()
791 new, self->daddr); irnet_find_socket()
826 * Function irda_connect_socket (self)
901 * Function irda_disconnect_server (self)
907 irnet_disconnect_server(irnet_socket * self, irnet_disconnect_server() argument
910 DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self); irnet_disconnect_server()
919 irttp_disconnect_request(self->tsap, NULL, P_NORMAL); irnet_disconnect_server()
924 self->saddr, self->daddr, self->rname, 0); irnet_disconnect_server()
927 irttp_listen(self->tsap); irnet_disconnect_server()
934 * Function irda_setup_server (self)
984 DEXIT(IRDA_SERV_TRACE, " - self=0x%p\n", &irnet_server.s); irnet_setup_server()
990 * Function irda_destroy_server (self)
1040 DENTER(IRDA_TCB_TRACE, "(self/ap=0x%p, skb=0x%p)\n", irnet_data_indication()
1107 irnet_socket * self = (irnet_socket *) instance; irnet_disconnect_indication() local
1111 DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self); irnet_disconnect_indication()
1112 DASSERT(self != NULL, , IRDA_CB_ERROR, "Self is NULL !!!\n"); irnet_disconnect_indication()
1119 test_open = test_and_clear_bit(0, &self->ttp_open); irnet_disconnect_indication()
1122 test_connect = test_and_clear_bit(0, &self->ttp_connect); irnet_disconnect_indication()
1124 /* If both self->ttp_open and self->ttp_connect are NULL, it mean that we irnet_disconnect_indication()
1136 irnet_post_event(self, IRNET_DISCONNECT_FROM, irnet_disconnect_indication()
1137 self->saddr, self->daddr, self->rname, 0); irnet_disconnect_indication()
1140 if((self->tsap) && (self != &irnet_server.s)) irnet_disconnect_indication()
1141 irnet_post_event(self, IRNET_NOANSWER_FROM, irnet_disconnect_indication()
1142 self->saddr, self->daddr, self->rname, 0); irnet_disconnect_indication()
1145 if((self->tsap) && (self != &irnet_server.s)) irnet_disconnect_indication()
1148 irttp_close_tsap(self->tsap); irnet_disconnect_indication()
1149 self->tsap = NULL; irnet_disconnect_indication()
1152 self->stsap_sel = 0; irnet_disconnect_indication()
1153 self->daddr = DEV_ADDR_ANY; irnet_disconnect_indication()
1154 self->tx_flow = FLOW_START; irnet_disconnect_indication()
1157 if(self->ppp_open) irnet_disconnect_indication()
1162 schedule_work(&self->disconnect_work); irnet_disconnect_indication()
1170 ppp_output_wakeup(&self->chan); irnet_disconnect_indication()
1192 irnet_socket * self = (irnet_socket *) instance; irnet_connect_confirm() local
1194 DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self); irnet_connect_confirm()
1197 if(! test_bit(0, &self->ttp_connect)) irnet_connect_confirm()
1204 self->max_header_size = max_header_size; irnet_connect_confirm()
1207 self->max_sdu_size_tx = max_sdu_size; irnet_connect_confirm()
1208 self->max_data_size = max_sdu_size; irnet_connect_confirm()
1211 self->max_data_size = irttp_get_max_seg_size(self->tsap); irnet_connect_confirm()
1215 self->saddr = irttp_get_saddr(self->tsap); irnet_connect_confirm()
1218 set_bit(0, &self->ttp_open); irnet_connect_confirm()
1219 clear_bit(0, &self->ttp_connect); /* Not racy, IrDA traffic is serial */ irnet_connect_confirm()
1221 ppp_output_wakeup(&self->chan); irnet_connect_confirm()
1239 irnet_post_event(self, IRNET_CONNECT_TO, irnet_connect_confirm()
1240 self->saddr, self->daddr, self->rname, 0); irnet_connect_confirm()
1257 irnet_socket * self = (irnet_socket *) instance; irnet_flow_indication() local
1258 LOCAL_FLOW oldflow = self->tx_flow; irnet_flow_indication()
1260 DENTER(IRDA_TCB_TRACE, "(self=0x%p, flow=%d)\n", self, flow); irnet_flow_indication()
1263 self->tx_flow = flow; irnet_flow_indication()
1272 ppp_output_wakeup(&self->chan); irnet_flow_indication()
1299 irnet_socket * self = (irnet_socket *) instance; irnet_status_indication() local
1301 DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self); irnet_status_indication()
1302 DASSERT(self != NULL, , IRDA_CB_ERROR, "Self is NULL !!!\n"); irnet_status_indication()
1308 irnet_post_event(self, IRNET_BLOCKED_LINK, irnet_status_indication()
1309 self->saddr, self->daddr, self->rname, 0); irnet_status_indication()
1487 irnet_socket * self = (irnet_socket *) priv; irnet_getvalue_confirm() local
1489 DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self); irnet_getvalue_confirm()
1490 DASSERT(self != NULL, , IRDA_OCB_ERROR, "Self is NULL !!!\n"); irnet_getvalue_confirm()
1494 if(! test_bit(0, &self->ttp_connect)) irnet_getvalue_confirm()
1501 iriap_close(self->iriap); irnet_getvalue_confirm()
1502 self->iriap = NULL; irnet_getvalue_confirm()
1505 self->dtsap_sel = irnet_ias_to_tsap(self, result, value); irnet_getvalue_confirm()
1508 if(self->errno) irnet_getvalue_confirm()
1510 clear_bit(0, &self->ttp_connect); irnet_getvalue_confirm()
1511 DERROR(IRDA_OCB_ERROR, "IAS connect failed ! (0x%X)\n", self->errno); irnet_getvalue_confirm()
1516 self->daddr, self->dtsap_sel); irnet_getvalue_confirm()
1519 irnet_connect_tsap(self); irnet_getvalue_confirm()
1550 irnet_socket * self = (irnet_socket *) priv; irnet_discovervalue_confirm() local
1553 DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self); irnet_discovervalue_confirm()
1554 DASSERT(self != NULL, , IRDA_OCB_ERROR, "Self is NULL !!!\n"); irnet_discovervalue_confirm()
1558 if(! test_bit(0, &self->ttp_connect)) irnet_discovervalue_confirm()
1565 dtsap_sel = irnet_ias_to_tsap(self, result, value); irnet_discovervalue_confirm()
1568 if(self->errno == 0) irnet_discovervalue_confirm()
1571 if(self->daddr != DEV_ADDR_ANY) irnet_discovervalue_confirm()
1578 self->daddr = self->discoveries[self->disco_index].daddr; irnet_discovervalue_confirm()
1579 self->dtsap_sel = dtsap_sel; irnet_discovervalue_confirm()
1584 if((self->errno == -EADDRNOTAVAIL) || (self->errno == 0)) irnet_discovervalue_confirm()
1589 ret = irnet_discover_next_daddr(self); irnet_discovervalue_confirm()
1602 iriap_close(self->iriap); irnet_discovervalue_confirm()
1603 self->iriap = NULL; irnet_discovervalue_confirm()
1607 self->discoveries); irnet_discovervalue_confirm()
1608 if(self->discoveries != NULL) irnet_discovervalue_confirm()
1611 kfree(self->discoveries); irnet_discovervalue_confirm()
1612 self->discoveries = NULL; irnet_discovervalue_confirm()
1614 self->disco_number = -1; irnet_discovervalue_confirm()
1617 if(self->daddr == DEV_ADDR_ANY) irnet_discovervalue_confirm()
1619 self->daddr = DEV_ADDR_ANY; irnet_discovervalue_confirm()
1620 clear_bit(0, &self->ttp_connect); irnet_discovervalue_confirm()
1628 self->daddr, self->dtsap_sel); irnet_discovervalue_confirm()
1631 irnet_connect_tsap(self); irnet_discovervalue_confirm()
1664 irnet_socket * self = &irnet_server.s; irnet_discovery_indication() local
1666 DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self); irnet_discovery_indication()
1695 irnet_socket * self = &irnet_server.s; irnet_expiry_indication() local
1697 DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self); irnet_expiry_indication()
1724 irnet_socket * self; irnet_proc_show() local
1743 self = (irnet_socket *) hashbin_get_first(irnet_server.list); irnet_proc_show()
1744 while(self != NULL) irnet_proc_show()
1750 seq_printf(m, "Requested IrDA name: \"%s\", ", self->rname); irnet_proc_show()
1751 seq_printf(m, "daddr: %08x, ", self->rdaddr); irnet_proc_show()
1752 seq_printf(m, "saddr: %08x\n", self->rsaddr); irnet_proc_show()
1756 (self->ppp_open ? "registered" : "unregistered")); irnet_proc_show()
1757 if(self->ppp_open) irnet_proc_show()
1760 ppp_unit_number(&self->chan)); irnet_proc_show()
1762 ppp_channel_index(&self->chan)); irnet_proc_show()
1764 self->mru); irnet_proc_show()
1765 /* Maybe add self->flags ? Later... */ irnet_proc_show()
1769 if(self->ttp_open) irnet_proc_show()
1772 if(self->tsap != NULL) irnet_proc_show()
1775 if(self->iriap != NULL) irnet_proc_show()
1778 if(self->ttp_connect) irnet_proc_show()
1783 seq_printf(m, "daddr: %08x, ", self->daddr); irnet_proc_show()
1784 seq_printf(m, "stsap_sel: %02x, ", self->stsap_sel); irnet_proc_show()
1785 seq_printf(m, "dtsap_sel: %02x\n", self->dtsap_sel); irnet_proc_show()
1788 self = (irnet_socket *) hashbin_get_next(irnet_server.list); irnet_proc_show()
|
| H A D | irnet_ppp.c | 177 * Function irnet_get_discovery_log (self)
203 * Function irnet_read_discovery_log (self, event)
922 irnet_socket * self = (struct irnet_socket *) chan->private; ppp_irnet_send() local
925 DENTER(PPP_TRACE, "(channel=0x%p, ap/self=0x%p)\n", ppp_irnet_send()
926 chan, self); ppp_irnet_send()
929 DASSERT(self != NULL, 0, PPP_ERROR, "Self is NULL !!!\n"); ppp_irnet_send()
932 if(!(test_bit(0, &self->ttp_open))) ppp_irnet_send()
939 irda_irnet_connect(self); ppp_irnet_send()
943 self->ttp_open, self->ttp_connect); ppp_irnet_send()
966 if(test_bit(0, &self->ttp_connect)) ppp_irnet_send()
979 if(self->tx_flow != FLOW_START) ppp_irnet_send()
981 skb_queue_len(&self->tsap->tx_queue)); ppp_irnet_send()
984 skb = irnet_prepare_skb(self, skb); ppp_irnet_send()
988 ret = irttp_data_request(self->tsap, skb); ppp_irnet_send()
1000 * Correction : we verify the flow control above (self->tx_flow), ppp_irnet_send()
|
| H A D | irnet.h | 147 * o fix a self->daddr to self->raddr in irda_irnet_connect to fix
162 * o Init self->max_header_size, just in case...
192 * asynchronous IAS query, self->tsap is NULL when PPP send the
194 * Change the test in ppp_irnet_send() to self->ttp_connect.
197 * o Tighten the use of self->ttp_connect and self->ttp_open to
200 * o Replace "self" with "server" in irnet_connect_indication() to
394 * "ap" or "self". If the code is borrowed from the IrDA stack, it tend
395 * to be called "self", and if it is borrowed from the PPP driver it is
|
| /linux-4.1.27/tools/perf/util/ |
| H A D | setup.py | 10 def finalize_options(self):
11 _build_ext.finalize_options(self)
12 self.build_lib = build_lib
13 self.build_temp = build_tmp
16 def finalize_options(self):
17 _install_lib.finalize_options(self)
18 self.build_dir = build_lib
|
| H A D | find-vdso-map.c | 7 maps = fopen("/proc/self/maps", "r"); find_vdso_map()
|
| /linux-4.1.27/scripts/tracing/ |
| H A D | draw_functrace.py | 35 def __init__(self, func, time = None, parent = None):
36 self._func = func
37 self._time = time
39 self._parent = CallTree.ROOT
41 self._parent = parent
42 self._children = []
44 def calls(self, func, calltime):
49 child = CallTree(func, calltime, self)
50 self._children.append(child)
53 def getParent(self, func):
59 tree = self
67 def __repr__(self):
68 return self.__toString("", True)
70 def __toString(self, branch, lastChild):
71 if self._time is not None:
72 s = "%s----%s (%s)\n" % (branch, self._func, self._time)
74 s = "%s----%s\n" % (branch, self._func)
79 while i < len(self._children):
80 if i != len(self._children) - 1:
81 s += "%s" % self._children[i].__toString(branch +\
84 s += "%s" % self._children[i].__toString(branch +\
|
| /linux-4.1.27/include/net/irda/ |
| H A D | iriap_event.h | 68 void iriap_next_client_state (struct iriap_cb *self, IRIAP_STATE state);
69 void iriap_next_call_state (struct iriap_cb *self, IRIAP_STATE state);
70 void iriap_next_server_state (struct iriap_cb *self, IRIAP_STATE state);
71 void iriap_next_r_connect_state(struct iriap_cb *self, IRIAP_STATE state);
74 void iriap_do_client_event(struct iriap_cb *self, IRIAP_EVENT event,
76 void iriap_do_call_event (struct iriap_cb *self, IRIAP_EVENT event,
79 void iriap_do_server_event (struct iriap_cb *self, IRIAP_EVENT event,
81 void iriap_do_r_connect_event(struct iriap_cb *self, IRIAP_EVENT event,
|
| H A D | ircomm_core.h | 85 int ircomm_close(struct ircomm_cb *self);
87 int ircomm_data_request(struct ircomm_cb *self, struct sk_buff *skb);
88 void ircomm_data_indication(struct ircomm_cb *self, struct sk_buff *skb);
89 void ircomm_process_data(struct ircomm_cb *self, struct sk_buff *skb);
90 int ircomm_control_request(struct ircomm_cb *self, struct sk_buff *skb);
91 int ircomm_connect_request(struct ircomm_cb *self, __u8 dlsap_sel,
94 void ircomm_connect_indication(struct ircomm_cb *self, struct sk_buff *skb,
96 void ircomm_connect_confirm(struct ircomm_cb *self, struct sk_buff *skb,
98 int ircomm_connect_response(struct ircomm_cb *self, struct sk_buff *userdata);
99 int ircomm_disconnect_request(struct ircomm_cb *self, struct sk_buff *userdata);
100 void ircomm_disconnect_indication(struct ircomm_cb *self, struct sk_buff *skb,
102 void ircomm_flow_request(struct ircomm_cb *self, LOCAL_FLOW flow);
104 #define ircomm_is_connected(self) (self->state == IRCOMM_CONN)
|
| H A D | irlmp.h | 198 void irlmp_close_lsap( struct lsap_cb *self);
216 void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb);
219 struct lsap_cb *irlmp_dup(struct lsap_cb *self, void *instance);
221 void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
245 void irlmp_flow_indication(struct lap_cb *self, LOCAL_FLOW flow);
249 static inline __u32 irlmp_get_saddr(const struct lsap_cb *self) irlmp_get_saddr() argument
251 return (self && self->lap) ? self->lap->saddr : 0; irlmp_get_saddr()
254 static inline __u32 irlmp_get_daddr(const struct lsap_cb *self) irlmp_get_daddr() argument
256 return (self && self->lap) ? self->lap->daddr : 0; irlmp_get_daddr()
269 static inline int irlmp_lap_tx_queue_full(struct lsap_cb *self) irlmp_lap_tx_queue_full() argument
271 if (self == NULL) irlmp_lap_tx_queue_full()
273 if (self->lap == NULL) irlmp_lap_tx_queue_full()
275 if (self->lap->irlap == NULL) irlmp_lap_tx_queue_full()
278 return IRLAP_GET_TX_QUEUE_LEN(self->lap->irlap) >= LAP_HIGH_THRESHOLD; irlmp_lap_tx_queue_full()
286 static inline void irlmp_listen(struct lsap_cb *self) irlmp_listen() argument
288 self->dlsap_sel = LSAP_ANY; irlmp_listen()
289 self->lap = NULL; irlmp_listen()
290 self->lsap_state = LSAP_DISCONNECTED; irlmp_listen()
292 del_timer(&self->watchdog_timer); irlmp_listen()
|
| H A D | irttp.h | 156 int irttp_close_tsap(struct tsap_cb *self);
158 int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb);
159 int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb);
161 int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
165 int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
167 int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *skb,
169 void irttp_flow_request(struct tsap_cb *self, LOCAL_FLOW flow);
170 struct tsap_cb *irttp_dup(struct tsap_cb *self, void *instance);
172 static inline __u32 irttp_get_saddr(struct tsap_cb *self) irttp_get_saddr() argument
174 return irlmp_get_saddr(self->lsap); irttp_get_saddr()
177 static inline __u32 irttp_get_daddr(struct tsap_cb *self) irttp_get_daddr() argument
179 return irlmp_get_daddr(self->lsap); irttp_get_daddr()
182 static inline __u32 irttp_get_max_seg_size(struct tsap_cb *self) irttp_get_max_seg_size() argument
184 return self->max_seg_size; irttp_get_max_seg_size()
192 static inline void irttp_listen(struct tsap_cb *self) irttp_listen() argument
194 irlmp_listen(self->lsap); irttp_listen()
195 self->dtsap_sel = LSAP_ANY; irttp_listen()
200 static inline int irttp_is_primary(struct tsap_cb *self) irttp_is_primary() argument
202 if ((self == NULL) || irttp_is_primary()
203 (self->lsap == NULL) || irttp_is_primary()
204 (self->lsap->lap == NULL) || irttp_is_primary()
205 (self->lsap->lap->irlap == NULL)) irttp_is_primary()
207 return irlap_is_primary(self->lsap->lap->irlap); irttp_is_primary()
|
| H A D | irlan_common.h | 201 void irlan_close(struct irlan_cb *self);
202 void irlan_close_tsaps(struct irlan_cb *self);
204 int irlan_register_netdev(struct irlan_cb *self);
205 void irlan_ias_register(struct irlan_cb *self, __u8 tsap_sel);
206 void irlan_start_watchdog_timer(struct irlan_cb *self, int timeout);
208 void irlan_open_data_tsap(struct irlan_cb *self);
210 int irlan_run_ctrl_tx_queue(struct irlan_cb *self);
213 void irlan_get_provider_info(struct irlan_cb *self);
214 void irlan_get_media_char(struct irlan_cb *self);
215 void irlan_open_data_channel(struct irlan_cb *self);
216 void irlan_close_data_channel(struct irlan_cb *self);
217 void irlan_set_multicast_filter(struct irlan_cb *self, int status);
218 void irlan_set_broadcast_filter(struct irlan_cb *self, int status);
|
| H A D | irlan_event.h | 72 void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
75 void irlan_do_provider_event(struct irlan_cb *self, IRLAN_EVENT event,
78 void irlan_next_client_state(struct irlan_cb *self, IRLAN_STATE state);
79 void irlan_next_provider_state(struct irlan_cb *self, IRLAN_STATE state);
|
| H A D | irlan_provider.h | 42 int irlan_parse_open_data_cmd(struct irlan_cb *self, struct sk_buff *skb);
43 int irlan_provider_parse_command(struct irlan_cb *self, int cmd,
46 void irlan_provider_send_reply(struct irlan_cb *self, int command,
48 int irlan_provider_open_ctrl_tsap(struct irlan_cb *self);
|
| H A D | irlmp_frame.h | 42 void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
44 void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
55 void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
59 void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log);
|
| H A D | timer.h | 90 void irlap_start_slot_timer(struct irlap_cb *self, int timeout);
91 void irlap_start_query_timer(struct irlap_cb *self, int S, int s);
92 void irlap_start_final_timer(struct irlap_cb *self, int timeout);
93 void irlap_start_wd_timer(struct irlap_cb *self, int timeout);
94 void irlap_start_backoff_timer(struct irlap_cb *self, int timeout);
96 void irlap_start_mbusy_timer(struct irlap_cb *self, int timeout);
102 void irlmp_stop_idle_timer(struct lap_cb *self);
|
| H A D | ircomm_tty_attach.h | 70 int ircomm_tty_do_event(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event,
74 int ircomm_tty_attach_cable(struct ircomm_tty_cb *self);
75 void ircomm_tty_detach_cable(struct ircomm_tty_cb *self);
89 int ircomm_tty_send_initial_parameters(struct ircomm_tty_cb *self);
90 void ircomm_tty_link_established(struct ircomm_tty_cb *self);
|
| H A D | iriap.h | 95 void iriap_close(struct iriap_cb *self);
97 int iriap_getvaluebyclass_request(struct iriap_cb *self,
100 void iriap_connect_request(struct iriap_cb *self);
101 void iriap_send_ack( struct iriap_cb *self);
102 void iriap_call_indication(struct iriap_cb *self, struct sk_buff *skb);
|
| H A D | irlap.h | 202 struct qos_info qos_rx; /* QoS requested by self */
223 void irlap_close(struct irlap_cb *self);
225 void irlap_connect_request(struct irlap_cb *self, __u32 daddr,
227 void irlap_connect_response(struct irlap_cb *self, struct sk_buff *skb);
228 void irlap_connect_indication(struct irlap_cb *self, struct sk_buff *skb);
250 void irlap_reset_indication(struct irlap_cb *self);
262 void irlap_apply_default_connection_parameters(struct irlap_cb *self);
263 void irlap_apply_connection_parameters(struct irlap_cb *self, int now);
265 #define IRLAP_GET_HEADER_SIZE(self) (LAP_MAX_HEADER)
266 #define IRLAP_GET_TX_QUEUE_LEN(self) skb_queue_len(&self->txq)
270 static inline int irlap_is_primary(struct irlap_cb *self) irlap_is_primary() argument
273 switch(self->state) { irlap_is_primary()
289 static inline void irlap_clear_disconnect(struct irlap_cb *self) irlap_clear_disconnect() argument
291 self->disconnect_pending = FALSE; irlap_clear_disconnect()
295 * Function irlap_next_state (self, state)
300 static inline void irlap_next_state(struct irlap_cb *self, IRLAP_STATE state) irlap_next_state() argument
303 if (!self || self->magic != LAP_MAGIC) irlap_next_state()
308 self->state = state; irlap_next_state()
|
| H A D | irlap_frame.h | 141 void irlap_queue_xmit(struct irlap_cb *self, struct sk_buff *skb);
146 void irlap_send_test_frame(struct irlap_cb *self, __u8 caddr, __u32 daddr,
149 void irlap_send_dm_frame(struct irlap_cb *self);
150 void irlap_send_rd_frame(struct irlap_cb *self);
151 void irlap_send_disc_frame(struct irlap_cb *self);
152 void irlap_send_rr_frame(struct irlap_cb *self, int command);
159 void irlap_resend_rejected_frame(struct irlap_cb *self, int command);
161 void irlap_send_ui_frame(struct irlap_cb *self, struct sk_buff *skb,
164 int irlap_insert_qos_negotiation_params(struct irlap_cb *self,
|
| H A D | irlan_filter.h | 28 void irlan_check_command_param(struct irlan_cb *self, char *param,
30 void irlan_filter_request(struct irlan_cb *self, struct sk_buff *skb);
|
| H A D | parameters.h | 69 typedef int (*PI_HANDLER)(void *self, irda_param_t *param, int get);
70 typedef int (*PV_HANDLER)(void *self, __u8 *buf, int len, __u8 pi,
92 int irda_param_insert(void *self, __u8 pi, __u8 *buf, int len,
94 int irda_param_extract_all(void *self, __u8 *buf, int len,
|
| H A D | ircomm_event.h | 79 int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event,
81 void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state);
|
| H A D | irlan_client.h | 37 void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr);
39 void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb);
|
| H A D | ircomm_tty.h | 96 * o self->ctrl_skb
97 * o self->tx_skb
104 void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self);
|
| H A D | ircomm_lmp.h | 34 int ircomm_open_lsap(struct ircomm_cb *self);
|
| H A D | ircomm_ttp.h | 34 int ircomm_open_tsap(struct ircomm_cb *self);
|
| H A D | irlap_event.h | 123 void irlap_do_event(struct irlap_cb *self, IRLAP_EVENT event,
127 int irlap_qos_negotiate(struct irlap_cb *self, struct sk_buff *skb);
|
| H A D | irlmp_event.h | 89 void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event,
91 int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
|
| /linux-4.1.27/arch/sparc/include/asm/ |
| H A D | cacheflush.h | 4 /* flush addr - to allow use of self-modifying code */
|
| H A D | kprobes.h | 46 int kprobe_exceptions_notify(struct notifier_block *self,
|
| /linux-4.1.27/scripts/ |
| H A D | analyze_suspend.py | 110 def __init__(self):
111 self.hostname = platform.node()
112 if(self.hostname == ''):
113 self.hostname = 'localhost'
120 self.rtcpath = rtc
121 def setOutputFile(self):
122 if((self.htmlfile == '') and (self.dmesgfile != '')):
123 m = re.match('(?P<name>.*)_dmesg\.txt$', self.dmesgfile)
125 self.htmlfile = m.group('name')+'.html'
126 if((self.htmlfile == '') and (self.ftracefile != '')):
127 m = re.match('(?P<name>.*)_ftrace\.txt$', self.ftracefile)
129 self.htmlfile = m.group('name')+'.html'
130 if(self.htmlfile == ''):
131 self.htmlfile = 'output.html'
132 def initTestOutput(self, subdir):
133 if(not self.android):
134 self.prefix = self.hostname
138 self.prefix = 'android'
139 v = os.popen(self.adb+' shell cat /proc/version').read().strip()
143 self.testdir = subdir+"/"+testtime
145 self.testdir = testtime
146 self.teststamp = \
147 '# '+testtime+' '+self.prefix+' '+self.suspendmode+' '+kver
148 self.dmesgfile = \
149 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_dmesg.txt'
150 self.ftracefile = \
151 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_ftrace.txt'
152 self.htmlfile = \
153 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'.html'
154 os.mkdir(self.testdir)
155 def setDeviceFilter(self, devnames):
156 self.devicefilter = string.split(devnames)
157 def rtcWakeAlarm(self):
158 os.system('echo 0 > '+self.rtcpath+'/wakealarm')
159 outD = open(self.rtcpath+'/date', 'r').read().strip()
160 outT = open(self.rtcpath+'/time', 'r').read().strip()
173 alarm = nowtime + self.rtcwaketime
174 os.system('echo %d > %s/wakealarm' % (alarm, self.rtcpath))
186 def __init__(self, nodename, nodedepth):
187 self.name = nodename
188 self.children = []
189 self.depth = nodedepth
231 def __init__(self, num):
233 self.testnumber = num
234 self.idstr = idchar[num]
235 self.dmesgtext = []
236 self.phases = []
237 self.dmesg = { # fixed list of 10 phases
259 self.phases = self.sortedPhases()
260 def getStart(self):
261 return self.dmesg[self.phases[0]]['start']
262 def setStart(self, time):
263 self.start = time
264 self.dmesg[self.phases[0]]['start'] = time
265 def getEnd(self):
266 return self.dmesg[self.phases[-1]]['end']
267 def setEnd(self, time):
268 self.end = time
269 self.dmesg[self.phases[-1]]['end'] = time
270 def isTraceEventOutsideDeviceCalls(self, pid, time):
271 for phase in self.phases:
272 list = self.dmesg[phase]['list']
279 def addIntraDevTraceEvent(self, action, name, pid, time):
292 for phase in self.phases:
293 list = self.dmesg[phase]['list']
305 def capIntraDevTraceEvent(self, action, name, pid, time):
306 for phase in self.phases:
307 list = self.dmesg[phase]['list']
321 def trimTimeVal(self, t, t0, dT, left):
336 def trimTime(self, t0, dT, left):
337 self.tSuspended = self.trimTimeVal(self.tSuspended, t0, dT, left)
338 self.tResumed = self.trimTimeVal(self.tResumed, t0, dT, left)
339 self.start = self.trimTimeVal(self.start, t0, dT, left)
340 self.end = self.trimTimeVal(self.end, t0, dT, left)
341 for phase in self.phases:
342 p = self.dmesg[phase]
343 p['start'] = self.trimTimeVal(p['start'], t0, dT, left)
344 p['end'] = self.trimTimeVal(p['end'], t0, dT, left)
348 d['start'] = self.trimTimeVal(d['start'], t0, dT, left)
349 d['end'] = self.trimTimeVal(d['end'], t0, dT, left)
352 cg.start = self.trimTimeVal(cg.start, t0, dT, left)
353 cg.end = self.trimTimeVal(cg.end, t0, dT, left)
355 line.time = self.trimTimeVal(line.time, t0, dT, left)
358 e.time = self.trimTimeVal(e.time, t0, dT, left)
359 def normalizeTime(self, tZero):
361 if(self.tSuspended != self.tResumed):
362 if(self.tResumed > tZero):
363 self.trimTime(self.tSuspended, \
364 self.tResumed-self.tSuspended, True)
366 self.trimTime(self.tSuspended, \
367 self.tResumed-self.tSuspended, False)
369 self.tSuspended -= tZero
370 self.tResumed -= tZero
371 self.start -= tZero
372 self.end -= tZero
373 for phase in self.phases:
374 p = self.dmesg[phase]
391 def newPhaseWithSingleAction(self, phasename, devname, start, end, color):
392 for phase in self.phases:
393 self.dmesg[phase]['order'] += 1
394 self.html_device_id += 1
395 devid = '%s%d' % (self.idstr, self.html_device_id)
400 self.dmesg[phasename] = \
403 self.phases = self.sortedPhases()
404 def newPhase(self, phasename, start, end, color, order):
406 order = len(self.phases)
407 for phase in self.phases[order:]:
408 self.dmesg[phase]['order'] += 1
410 p = self.phases[order-1]
411 self.dmesg[p]['end'] = start
412 if(order < len(self.phases)):
413 p = self.phases[order]
414 self.dmesg[p]['start'] = end
416 self.dmesg[phasename] = \
419 self.phases = self.sortedPhases()
420 def setPhase(self, phase, ktime, isbegin):
422 self.dmesg[phase]['start'] = ktime
424 self.dmesg[phase]['end'] = ktime
425 def dmesgSortVal(self, phase):
426 return self.dmesg[phase]['order']
427 def sortedPhases(self):
428 return sorted(self.dmesg, key=self.dmesgSortVal)
429 def sortedDevices(self, phase):
430 list = self.dmesg[phase]['list']
439 def fixupInitcalls(self, phase, end):
441 phaselist = self.dmesg[phase]['list']
447 def deviceFilter(self, devicefilter):
450 for phase in self.phases:
451 list = self.dmesg[phase]['list']
458 children = self.deviceDescendants(name, phase)
462 for phase in self.phases:
463 list = self.dmesg[phase]['list']
471 def fixupInitcallsThatDidntReturn(self):
473 for phase in self.phases:
474 self.fixupInitcalls(phase, self.getEnd())
475 def newActionGlobal(self, name, start, end):
479 for phase in self.phases:
480 pstart = self.dmesg[phase]['start']
481 pend = self.dmesg[phase]['end']
486 if targetphase in self.phases:
487 self.newAction(targetphase, name, -1, '', start, end, '')
490 def newAction(self, phase, name, pid, parent, start, end, drv):
492 self.html_device_id += 1
493 devid = '%s%d' % (self.idstr, self.html_device_id)
494 list = self.dmesg[phase]['list']
500 def deviceIDs(self, devlist, phase):
502 list = self.dmesg[phase]['list']
507 def deviceParentID(self, devname, phase):
510 list = self.dmesg[phase]['list']
516 def deviceChildren(self, devname, phase):
518 list = self.dmesg[phase]['list']
523 def deviceDescendants(self, devname, phase):
524 children = self.deviceChildren(devname, phase)
527 family += self.deviceDescendants(child, phase)
529 def deviceChildrenIDs(self, devname, phase):
530 devlist = self.deviceChildren(devname, phase)
531 return self.deviceIDs(devlist, phase)
532 def printDetails(self):
533 vprint(' test start: %f' % self.start)
534 for phase in self.phases:
535 dc = len(self.dmesg[phase]['list'])
537 self.dmesg[phase]['start'], self.dmesg[phase]['end'], dc))
538 vprint(' test end: %f' % self.end)
539 def masterTopology(self, name, list, depth):
542 clist = self.deviceChildren(cname, 'resume')
543 cnode = self.masterTopology(cname, clist, depth+1)
546 def printTopology(self, node):
551 for phase in self.phases:
552 list = self.dmesg[phase]['list']
566 html += self.printTopology(cnode)
569 def rootDeviceList(self):
572 for phase in self.dmesg:
573 list = self.dmesg[phase]['list']
579 for phase in self.dmesg:
580 list = self.dmesg[phase]['list']
588 def deviceTopology(self):
589 rootlist = self.rootDeviceList()
590 master = self.masterTopology('', rootlist, 0)
591 return self.printTopology(master)
603 def __init__(self, a, n, c, t):
604 self.action = a
605 self.name = n
606 self.color = c
607 self.time = t
629 def __init__(self, t, m, d):
630 self.time = float(t)
643 self.name = emm.group('msg')
644 self.type = emm.group('call')
646 self.name = msg
647 self.fevent = True
651 self.length = float(d)/1000000
656 self.depth = self.getDepth(match.group('d'))
660 self.freturn = True
665 self.name = match.group('n')
668 self.fcall = True
673 self.name = match.group('n')
676 self.freturn = True
679 self.name = match.group('n')
682 self.name = m
683 def getDepth(self, str):
685 def debugPrint(self, dev):
686 if(self.freturn and self.fcall):
687 print('%s -- %f (%02d): %s(); (%.3f us)' % (dev, self.time, \
688 self.depth, self.name, self.length*1000000))
689 elif(self.freturn):
690 print('%s -- %f (%02d): %s} (%.3f us)' % (dev, self.time, \
691 self.depth, self.name, self.length*1000000))
693 print('%s -- %f (%02d): %s() { (%.3f us)' % (dev, self.time, \
694 self.depth, self.name, self.length*1000000))
708 def __init__(self):
709 self.start = -1.0
710 self.end = -1.0
711 self.list = []
712 self.depth = 0
713 def setDepth(self, line):
715 line.depth = self.depth
716 self.depth += 1
718 self.depth -= 1
719 line.depth = self.depth
721 line.depth = self.depth
722 def addLine(self, line, match):
723 if(not self.invalid):
724 self.setDepth(line)
726 if(self.start < 0):
727 self.start = line.time
728 self.end = line.time
729 self.list.append(line)
731 if(self.invalid):
733 if(len(self.list) >= 1000000 or self.depth < 0):
734 if(len(self.list) > 0):
735 first = self.list[0]
736 self.list = []
737 self.list.append(first)
738 self.invalid = True
742 window = '(%f - %f)' % (self.start, line.time)
743 if(self.depth < 0):
750 self.list.append(line)
751 if(self.start < 0):
752 self.start = line.time
754 def slice(self, t0, tN):
758 for l in self.list:
773 def sanityCheck(self):
776 for l in self.list:
790 def debugPrint(self, filename):
792 print('[%f - %f]') % (self.start, self.end)
793 for l in self.list:
807 for l in self.list:
831 def __init__(self):
832 self.html = {
837 def setRows(self, rows):
838 self.maxrows = int(rows)
839 self.scaleH = 100.0/float(self.maxrows)
840 self.height = self.maxrows*self.row_height_pixels
841 r = float(self.maxrows - 1)
844 self.rowH = (100.0 - self.scaleH)/r
866 def __init__(self, dataobj):
867 self.data = dataobj
868 self.ftemp = dict()
869 self.ttemp = dict()
870 def isReady(self):
874 def setTracerType(self, tracer):
875 self.tracertype = tracer
877 self.cgformat = True
878 self.ftrace_line_fmt = self.ftrace_line_fmt_fg
880 self.ftrace_line_fmt = self.ftrace_line_fmt_nop
|
| /linux-4.1.27/include/soc/tegra/ |
| H A D | pm.h | 15 TEGRA_SUSPEND_LP1, /* CPU voltage off, DRAM self-refresh */
16 TEGRA_SUSPEND_LP0, /* CPU + core voltage off, DRAM self-refresh */
|
| /linux-4.1.27/arch/sh/boards/mach-kfr2r09/ |
| H A D | sdram.S | 2 * KFR2R09 sdram self/auto-refresh setup code
18 /* code to enter and leave self-refresh. must be self-contained.
24 /* DBSC: put memory in self-refresh mode */
|
| /linux-4.1.27/tools/testing/selftests/mount/ |
| H A D | Makefile | 12 override RUN_TESTS := if [ -f /proc/self/uid_map ] ; then ./unprivileged-remount-test ; fi
|
| H A D | unprivileged-remount-test.c | 166 maybe_write_file("/proc/self/setgroups", "deny"); create_and_enter_userns()
167 write_file("/proc/self/uid_map", "0 %d 1", uid); create_and_enter_userns()
168 write_file("/proc/self/gid_map", "0 %d 1", gid); create_and_enter_userns()
231 /* system("cat /proc/self/mounts"); */ test_unpriv_remount()
238 /* system("cat /proc/self/mounts"); */ test_unpriv_remount()
305 /* system("cat /proc/self/mounts"); */ test_priv_mount_unpriv_remount()
|
| /linux-4.1.27/arch/arm/mach-lpc32xx/ |
| H A D | suspend.S | 66 @ Setup self-refresh with support for manual exit of
67 @ self-refresh mode
73 @ Wait for self-refresh acknowledge, clocks to the DRAM device
74 @ will automatically stop on start of self-refresh
79 bne 3b @ Branch until self-refresh mode starts
116 @ Re-enter run mode with self-refresh flag cleared, but no DRAM
117 @ update yet. DRAM is still in self-refresh
125 @ Clear self-refresh mode
132 @ Wait for EMC to clear self-refresh mode
136 bne 5b @ Branch until self-refresh has exited
|
| H A D | pm.c | 46 * and exit DRAM self-refresh modes must not be executed in DRAM. A small
53 * Places DRAMs in self-refresh mode
137 * Setup SDRAM self-refresh clock to automatically disable o lpc32xx_pm_init()
138 * start of self-refresh. This only needs to be done once. lpc32xx_pm_init()
|
| /linux-4.1.27/arch/sh/boards/mach-ecovec24/ |
| H A D | sdram.S | 2 * Ecovec24 sdram self/auto-refresh setup code
18 /* code to enter and leave self-refresh. must be self-contained.
24 /* DBSC: put memory in self-refresh mode */
|
| /linux-4.1.27/drivers/pci/ |
| H A D | of.c | 34 if (bus->self == NULL) pci_set_bus_of_node()
37 bus->dev.of_node = of_node_get(bus->self->dev.of_node); pci_set_bus_of_node()
49 if (WARN_ON(bus->self || bus->parent)) pcibios_get_phb_of_node()
|
| H A D | pci.h | 155 if (dev->bus->self) pci_no_d1d2()
156 parent_dstates = dev->bus->self->no_d1d2; pci_no_d1d2()
227 return bus->self && bus->self->ari_enabled; pci_ari_enabled()
249 struct pci_dev *self; /* this PF */ member in struct:pci_sriov
|
| /linux-4.1.27/drivers/cpuidle/ |
| H A D | cpuidle-zynq.c | 20 * The cpu idle uses wait-for-interrupt and RAM self refresh in order
23 * #2 wait-for-interrupt and RAM self refresh
39 /* Add code for DDR self refresh start */ zynq_enter_idle()
|
| H A D | cpuidle-at91.c | 10 * The cpu idle uses wait-for-interrupt and RAM self refresh in order
13 * #2 wait-for-interrupt and RAM self refresh
|
| H A D | cpuidle-kirkwood.c | 8 * The cpu idle uses wait-for-interrupt and DDR self refresh in order
11 * #2 wait-for-interrupt and DDR self refresh
|
| /linux-4.1.27/drivers/crypto/qat/qat_dh895xcc/ |
| H A D | adf_dh895xcc_hw_data.c | 82 static uint32_t get_num_accels(struct adf_hw_device_data *self) get_num_accels() argument
86 if (!self || !self->accel_mask) get_num_accels()
90 if (self->accel_mask & (1 << i)) get_num_accels()
96 static uint32_t get_num_aes(struct adf_hw_device_data *self) get_num_aes() argument
100 if (!self || !self->ae_mask) get_num_aes()
104 if (self->ae_mask & (1 << i)) get_num_aes()
110 static uint32_t get_misc_bar_id(struct adf_hw_device_data *self) get_misc_bar_id() argument
115 static uint32_t get_etr_bar_id(struct adf_hw_device_data *self) get_etr_bar_id() argument
120 static enum dev_sku_info get_sku(struct adf_hw_device_data *self) get_sku() argument
122 int sku = (self->fuses & ADF_DH895XCC_FUSECTL_SKU_MASK) get_sku()
|
| /linux-4.1.27/kernel/ |
| H A D | backtracetest.c | 23 pr_info("The following trace is a kernel self test and not a bug!\n"); backtrace_test_normal()
41 pr_info("The following trace is a kernel self test and not a bug!\n"); backtrace_test_irq()
55 pr_info("The following trace is a kernel self test and not a bug!\n"); backtrace_test_saved()
|
| H A D | kthread.c | 157 static void __kthread_parkme(struct kthread *self) __kthread_parkme() argument
160 while (test_bit(KTHREAD_SHOULD_PARK, &self->flags)) { __kthread_parkme()
161 if (!test_and_set_bit(KTHREAD_IS_PARKED, &self->flags)) __kthread_parkme()
162 complete(&self->parked); __kthread_parkme()
166 clear_bit(KTHREAD_IS_PARKED, &self->flags); __kthread_parkme()
182 struct kthread self; kthread() local
185 self.flags = 0; kthread()
186 self.data = data; kthread()
187 init_completion(&self.exited); kthread()
188 init_completion(&self.parked); kthread()
189 current->vfork_done = &self.exited; kthread()
205 if (!test_bit(KTHREAD_SHOULD_STOP, &self.flags)) { kthread()
206 __kthread_parkme(&self); kthread()
209 /* we can't just return, we must preserve "self" on stack */ kthread()
|
| /linux-4.1.27/arch/arm/mach-at91/ |
| H A D | pm_suspend.S | 105 /* Active the self-refresh mode */
182 /* Exit the self-refresh mode */
194 * @r0: 1 - active self-refresh mode
195 * 0 - exit self-refresh mode
213 * For exiting the self-refresh mode, do nothing,
214 * automatically exit the self-refresh mode.
219 /* Active SDRAM self-refresh mode */
234 /* LPDDR1 --> force DDR2 mode during self-refresh */
244 /* Active DDRC self-refresh mode */
265 /* Active DDRC self-refresh mode */
300 /* Active SDRAMC self-refresh mode */
|
| H A D | pm.c | 226 * The AT91RM9200 goes into self-refresh mode with this command, and will
227 * terminate self-refresh automatically on the next SDRAM access.
232 * still in self-refresh is "not recommended", but seems to work.
257 /* Those two values allow us to delay self-refresh activation at91_ddr_standby()
272 /* self-refresh mode now */ at91_ddr_standby()
302 /* self-refresh mode now */ at91sam9_sdram_standby()
415 * AT91RM9200 SDRAM low-power mode cannot be used with self-refresh. at91rm9200_pm_init()
|
| /linux-4.1.27/arch/sh/include/asm/ |
| H A D | suspend.h | 32 /* board code registration function for self-refresh assembly snippets */ sh_mobile_setup_cpuidle()
62 /* addresses of board specific self-refresh snippets */
92 #define SUSP_SH_SF (1 << 4) /* Enable self-refresh */
|
| H A D | kprobes.h | 49 extern int kprobe_exceptions_notify(struct notifier_block *self,
|
| /linux-4.1.27/drivers/usb/core/ |
| H A D | buffer.c | 65 if (!hcd->self.controller->dma_mask && hcd_buffer_create()
74 hcd->pool[i] = dma_pool_create(name, hcd->self.controller, hcd_buffer_create()
131 return dma_alloc_coherent(hcd->self.controller, size, dma, mem_flags); hcd_buffer_alloc()
159 dma_free_coherent(hcd->self.controller, size, addr, dma); hcd_buffer_free()
|
| H A D | hcd.c | 442 s = hcd->self.bus_name; rh_string()
529 tbuf[0] = (device_may_wakeup(&hcd->self.root_hub->dev) rh_call_control()
537 device_set_wakeup_enable(&hcd->self.root_hub->dev, 0); rh_call_control()
542 if (device_can_wakeup(&hcd->self.root_hub->dev) rh_call_control()
544 device_set_wakeup_enable(&hcd->self.root_hub->dev, 1); rh_call_control()
595 if (device_can_wakeup(&hcd->self.root_hub->dev)) rh_call_control()
619 dev_dbg (hcd->self.controller, "root hub device address %d\n", rh_call_control()
635 dev_dbg (hcd->self.controller, "no endpoint features yet\n"); rh_call_control()
660 usb_hub_adjust_deviceremovable(hcd->self.root_hub, rh_call_control()
671 dev_dbg (hcd->self.controller, rh_call_control()
783 dev_dbg (hcd->self.controller, "not queuing rh status urb\n"); rh_queue_status()
1003 struct device *parent_dev = hcd->self.controller; register_root_hub()
1004 struct usb_device *usb_dev = hcd->self.root_hub; register_root_hub()
1361 dma_unmap_single(hcd->self.controller, usb_hcd_unmap_urb_setup_for_dma()
1393 dma_unmap_sg(hcd->self.controller, usb_hcd_unmap_urb_for_dma()
1398 dma_unmap_page(hcd->self.controller, usb_hcd_unmap_urb_for_dma()
1403 dma_unmap_single(hcd->self.controller, usb_hcd_unmap_urb_for_dma()
1442 if (hcd->self.uses_pio_for_control) usb_hcd_map_urb_for_dma()
1444 if (hcd->self.uses_dma) { usb_hcd_map_urb_for_dma()
1446 hcd->self.controller, usb_hcd_map_urb_for_dma()
1450 if (dma_mapping_error(hcd->self.controller, usb_hcd_map_urb_for_dma()
1470 if (hcd->self.uses_dma) { usb_hcd_map_urb_for_dma()
1481 hcd->self.controller, usb_hcd_map_urb_for_dma()
1496 hcd->self.controller, usb_hcd_map_urb_for_dma()
1501 if (dma_mapping_error(hcd->self.controller, usb_hcd_map_urb_for_dma()
1511 hcd->self.controller, usb_hcd_map_urb_for_dma()
1515 if (dma_mapping_error(hcd->self.controller, usb_hcd_map_urb_for_dma()
1558 usbmon_urb_submit(&hcd->self, urb); usb_hcd_submit_urb()
1580 usbmon_urb_submit_error(&hcd->self, urb, status); usb_hcd_submit_urb()
1668 usbmon_urb_complete(&hcd->self, urb, status); __usb_hcd_giveback_urb()
1811 dev_dbg (hcd->self.controller, usb_hcd_flush_endpoint()
2160 struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self); hcd_bus_suspend()
2209 struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self); hcd_bus_resume()
2268 struct usb_device *udev = hcd->self.root_hub; hcd_resume_work()
2323 hcd = container_of (bus, struct usb_hcd, self); usb_bus_start_enum()
2382 dev_err (hcd->self.controller, "HC died; cleaning up\n"); usb_hc_died()
2391 usb_set_device_state (hcd->self.root_hub, usb_hc_died()
2393 usb_kick_hub_wq(hcd->self.root_hub); usb_hc_died()
2401 usb_set_device_state(hcd->self.root_hub, usb_hc_died()
2403 usb_kick_hub_wq(hcd->self.root_hub); usb_hc_died()
2424 * @dev: device for this HC, stored in hcd->self.controller
2425 * @bus_name: value to store in hcd->self.bus_name
2479 usb_bus_init(&hcd->self); usb_create_shared_hcd()
2480 hcd->self.controller = dev; usb_create_shared_hcd()
2481 hcd->self.bus_name = bus_name; usb_create_shared_hcd()
2482 hcd->self.uses_dma = (dev->dma_mask != NULL); usb_create_shared_hcd()
2502 * @dev: device for this HC, stored in hcd->self.controller
2503 * @bus_name: value to store in hcd->self.bus_name
2589 hcd->driver->description, hcd->self.busnum); usb_hcd_request_irqs()
2593 dev_err(hcd->self.controller, usb_hcd_request_irqs()
2599 dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum, usb_hcd_request_irqs()
2606 dev_info(hcd->self.controller, "%s 0x%08llx\n", usb_hcd_request_irqs()
2623 rhdev = hcd->self.root_hub; usb_put_invalidate_rhdev()
2624 hcd->self.root_hub = NULL; usb_put_invalidate_rhdev()
2646 struct usb_phy *phy = usb_get_phy_dev(hcd->self.controller, 0); usb_add_hcd()
2664 struct phy *phy = phy_get(hcd->self.controller, "usb"); usb_add_hcd()
2687 dev_info(hcd->self.controller, "%s\n", hcd->product_desc); usb_add_hcd()
2701 dev_dbg(hcd->self.controller, "pool alloc failed\n"); usb_add_hcd()
2705 if ((retval = usb_register_bus(&hcd->self)) < 0) usb_add_hcd()
2708 if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) { usb_add_hcd()
2709 dev_err(hcd->self.controller, "unable to allocate root hub\n"); usb_add_hcd()
2714 hcd->self.root_hub = rhdev; usb_add_hcd()
2751 dev_err(hcd->self.controller, "can't setup: %d\n", retval); usb_add_hcd()
2757 if (device_can_wakeup(hcd->self.controller) usb_add_hcd()
2758 && device_can_wakeup(&hcd->self.root_hub->dev)) usb_add_hcd()
2759 dev_dbg(hcd->self.controller, "supports USB remote wakeup\n"); usb_add_hcd()
2777 dev_err(hcd->self.controller, "startup error %d\n", retval); usb_add_hcd()
2826 usb_deregister_bus(&hcd->self); usb_add_hcd()
2856 struct usb_device *rhdev = hcd->self.root_hub; usb_remove_hcd()
2858 dev_info(hcd->self.controller, "remove, state %x\n", hcd->state); usb_remove_hcd()
2867 dev_dbg(hcd->self.controller, "roothub graceful disconnect\n"); usb_remove_hcd()
2911 usb_deregister_bus(&hcd->self); usb_remove_hcd()
|
| H A D | generic.c | 65 * and it claims to be self-powered; other devices may have usb_choose_configuration()
75 * have any other way to tell whether a device is self-powered, usb_choose_configuration()
84 /* Rule out self-powered configs for a bus-powered device */ usb_choose_configuration()
93 * to be self-powered when they are really bus-powered. usb_choose_configuration()
|
| H A D | hcd-pci.c | 87 if (!companion_hcd || !companion_hcd->self.root_hub) for_each_pci_dev()
105 udev = companion_hcd->self.root_hub; ehci_pre_add()
125 companion_hcd->self.hs_companion = &hcd->self; ehci_post_add()
127 udev = companion_hcd->self.root_hub; ehci_post_add()
143 hcd->self.hs_companion = &companion_hcd->self; non_ehci_add()
152 companion_hcd->self.hs_companion = NULL; ehci_remove()
293 device_wakeup_enable(hcd->self.controller); usb_hcd_pci_probe()
359 hcd->self.hs_companion = NULL; usb_hcd_pci_remove()
|
| /linux-4.1.27/arch/s390/include/asm/ |
| H A D | uprobes.h | 37 int arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val,
|
| /linux-4.1.27/arch/sh/boards/mach-se/7724/ |
| H A D | sdram.S | 2 * MS7724SE sdram self/auto-refresh setup code
18 /* code to enter and leave self-refresh. must be self-contained.
24 /* DBSC: put memory in self-refresh mode */
|
| /linux-4.1.27/drivers/usb/host/ |
| H A D | ohci-s3c2410.c | 54 return dev_get_platdata(hcd->self.controller); to_s3c2410_info()
121 dev_dbg(hcd->self.controller, ohci_s3c2410_hub_status_data()
172 dev_dbg(hcd->self.controller, ohci_s3c2410_hub_control()
190 dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n"); ohci_s3c2410_hub_control()
199 dev_dbg(hcd->self.controller, ohci_s3c2410_hub_control()
210 dev_dbg(hcd->self.controller, ohci_s3c2410_hub_control()
219 dev_dbg(hcd->self.controller, ohci_s3c2410_hub_control()
244 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n", ohci_s3c2410_hub_control()
262 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n", ohci_s3c2410_hub_control()
270 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex); ohci_s3c2410_hub_control()
394 device_wakeup_enable(hcd->self.controller); usb_hcd_s3c2410_probe()
|
| H A D | ohci-omap.c | 179 const unsigned port = hcd->self.otg_port - 1; start_hnp()
201 struct omap_usb_config *config = dev_get_platdata(hcd->self.controller); ohci_omap_reset()
205 dev_dbg(hcd->self.controller, "starting USB Controller\n"); ohci_omap_reset()
208 hcd->self.otg_port = config->otg; ohci_omap_reset()
226 &ohci_to_hcd(ohci)->self); ohci_omap_reset()
227 dev_dbg(hcd->self.controller, "init %s phy, status %d\n", ohci_omap_reset()
234 dev_err(hcd->self.controller, "can't find phy\n"); ohci_omap_reset()
281 /* We require a self-powered hub, which should have ohci_omap_reset()
370 device_wakeup_enable(hcd->self.controller); usb_hcd_omap_probe()
399 dev_dbg(hcd->self.controller, "stopping USB Controller\n"); usb_hcd_omap_remove()
|
| H A D | ehci-xilinx-of.c | 52 dev_warn(hcd->self.controller, "port %d cannot be enabled\n", portnum); ehci_xilinx_port_handed_over()
54 dev_warn(hcd->self.controller, ehci_xilinx_port_handed_over()
57 dev_warn(hcd->self.controller, ehci_xilinx_port_handed_over()
60 dev_warn(hcd->self.controller, ehci_xilinx_port_handed_over()
62 dev_warn(hcd->self.controller, ehci_xilinx_port_handed_over()
65 dev_warn(hcd->self.controller, ehci_xilinx_port_handed_over()
197 device_wakeup_enable(hcd->self.controller); ehci_hcd_xilinx_of_probe()
|
| H A D | ohci-at91.c | 191 board = hcd->self.controller->platform_data; usb_hcd_at91_probe()
198 device_wakeup_enable(hcd->self.controller); usb_hcd_at91_probe()
261 struct at91_usbh_data *pdata = hcd->self.controller->platform_data; ohci_at91_hub_status_data()
282 struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller); ohci_at91_hub_control()
287 dev_dbg(hcd->self.controller, ohci_at91_hub_control()
296 dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n"); ohci_at91_hub_control()
309 dev_dbg(hcd->self.controller, ohci_at91_hub_control()
320 dev_dbg(hcd->self.controller, ohci_at91_hub_control()
329 dev_dbg(hcd->self.controller, ohci_at91_hub_control()
351 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n", ohci_at91_hub_control()
368 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n", ohci_at91_hub_control()
376 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex); ohci_at91_hub_control()
|
| H A D | sl811-hcd.c | 99 dev_dbg(hcd->self.controller, "power %s\n", port_power()
101 sl811->board->port_power(hcd->self.controller, is_on); port_power()
106 sl811->board->reset(hcd->self.controller); port_power()
282 dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq on\n"); sofirq_on()
290 dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq off\n"); sofirq_off()
338 dev_dbg(sl811_to_hcd(sl811)->self.controller, start()
392 dev_dbg(sl811_to_hcd(sl811)->self.controller, start()
449 dev_dbg(sl811_to_hcd(sl811)->self.controller,
463 sl811_to_hcd(sl811)->self.bandwidth_allocated
596 dev_dbg(sl811_to_hcd(sl811)->self.controller, checkdone()
608 dev_dbg(sl811_to_hcd(sl811)->self.controller, checkdone()
670 // dev_err(hcd->self.controller, "overrun to slot %d\n", index); sl811h_irq()
728 dev_dbg(hcd->self.controller, "wakeup\n"); sl811h_irq()
857 dev_dbg(hcd->self.controller, sl811h_urb_enqueue()
923 dev_dbg(hcd->self.controller, "schedule qh%d/%p branch %d\n", sl811h_urb_enqueue()
942 hcd->self.bandwidth_allocated += ep->load / ep->period; sl811h_urb_enqueue()
983 dev_dbg(hcd->self.controller, sl811h_urb_dequeue()
998 dev_dbg(hcd->self.controller, sl811h_urb_dequeue()
1017 dev_dbg(sl811_to_hcd(sl811)->self.controller, sl811h_urb_dequeue()
1039 dev_warn(hcd->self.controller, "ep %p not empty?\n", ep); sl811h_endpoint_disable()
1142 dev_dbg(sl811_to_hcd(sl811)->self.controller, "end reset\n"); sl811h_timer()
1151 dev_dbg(sl811_to_hcd(sl811)->self.controller, "end resume\n"); sl811h_timer()
1155 dev_dbg(sl811_to_hcd(sl811)->self.controller, sl811h_timer()
1254 dev_dbg(hcd->self.controller, "start resume...\n"); sl811h_hub_control()
1292 dev_dbg(hcd->self.controller, "GetPortStatus %08x\n", sl811h_hub_control()
1305 dev_dbg(hcd->self.controller,"suspend...\n"); sl811h_hub_control()
1350 dev_dbg(hcd->self.controller, "%s\n", __func__); sl811h_bus_suspend()
1358 dev_dbg(hcd->self.controller, "%s\n", __func__); sl811h_bus_resume()
1543 if (!device_can_wakeup(hcd->self.controller)) sl811h_start()
1544 device_init_wakeup(hcd->self.controller, sl811h_start()
1732 device_wakeup_enable(hcd->self.controller); sl811h_probe()
1785 if (!sl811->port1 || !device_can_wakeup(&hcd->self.root_hub->dev)) { sl811h_resume()
1788 usb_root_hub_lost_power(hcd->self.root_hub); sl811h_resume()
|
| H A D | ohci-jz4740.c | 50 dev_err(hcd->self.controller, "Can not start %s", ohci_jz4740_start()
51 hcd->self.bus_name); ohci_jz4740_start()
69 dev_err(jz4740_hcd_to_hcd(jz4740_ohci)->self.controller, ohci_jz4740_set_vbus_power()
205 device_wakeup_enable(hcd->self.controller); jz4740_ohci_probe()
|
| H A D | ehci-mem.c | 149 dma_free_coherent (ehci_to_hcd(ehci)->self.controller, ehci_mem_cleanup()
166 ehci_to_hcd(ehci)->self.controller, ehci_mem_init()
176 ehci_to_hcd(ehci)->self.controller, ehci_mem_init()
190 ehci_to_hcd(ehci)->self.controller, ehci_mem_init()
200 ehci_to_hcd(ehci)->self.controller, ehci_mem_init()
210 dma_alloc_coherent (ehci_to_hcd(ehci)->self.controller, ehci_mem_init()
|
| H A D | ohci-ppc-of.c | 34 dev_err(hcd->self.controller, "can't start %s\n", ohci_ppc_of_start()
35 hcd->self.bus_name); ohci_ppc_of_start()
145 device_wakeup_enable(hcd->self.controller); ohci_hcd_ppc_of_probe()
|
| H A D | ohci-ps3.c | 48 dev_err(hcd->self.controller, "can't start %s\n", ps3_ohci_hc_start()
49 hcd->self.bus_name); ps3_ohci_hc_start()
176 device_wakeup_enable(hcd->self.controller); ps3_ohci_probe()
|
| H A D | ohci-tilegx.c | 48 dev_err(hcd->self.controller, "can't start %s\n", tilegx_ohci_start()
49 hcd->self.bus_name); tilegx_ohci_start()
162 device_wakeup_enable(hcd->self.controller); ohci_hcd_tilegx_drv_probe()
|
| H A D | ohci-mem.c | 39 ohci_to_hcd(ohci)->self.controller, ohci_mem_init()
46 ohci_to_hcd(ohci)->self.controller, ohci_mem_init()
|
| H A D | max3421-hcd.c | 352 struct spi_device *spi = to_spi_device(hcd->self.controller); spi_rd8()
377 struct spi_device *spi = to_spi_device(hcd->self.controller); spi_wr8()
401 struct spi_device *spi = to_spi_device(hcd->self.controller); spi_rd_buf()
427 struct spi_device *spi = to_spi_device(hcd->self.controller); spi_wr_buf()
556 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_transfer_out()
662 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_select_and_start_urb()
798 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_check_unlink()
881 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_handle_error()
973 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_transfer_in_done()
1168 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_irq_handler()
1321 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_reset_hcd()
1400 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_spi_thread()
1495 hcd->self.sg_tablesize = 0; max3421_reset()
1497 hcd->self.root_hub->speed = USB_SPEED_FULL; max3421_reset()
1527 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_urb_enqueue()
1643 dev_dbg(hcd->self.controller, max3421_hub_status_data()
1699 struct spi_device *spi = to_spi_device(hcd->self.controller); max3421_hub_control()
1717 dev_dbg(hcd->self.controller, "power-off\n"); max3421_hub_control()
1766 dev_dbg(hcd->self.controller, "power-on\n"); max3421_hub_control()
1782 dev_dbg(hcd->self.controller, max3421_hub_control()
1918 if (hcd->self.controller == &spi->dev) max3421_remove()
|
| H A D | ohci-pci.c | 36 device_init_wakeup(&hcd->self.root_hub->dev, 0); broken_suspend()
73 struct pci_dev *pdev = to_pci_dev(hcd->self.controller); ohci_quirk_ns()
228 struct pci_dev *pdev = to_pci_dev(hcd->self.controller); ohci_pci_reset()
231 if (hcd->self.controller) { ohci_pci_reset()
|
| H A D | ehci-fsl.c | 127 device_wakeup_enable(hcd->self.controller); usb_hcd_fsl_probe()
139 &ehci_to_hcd(ehci)->self); usb_hcd_fsl_probe()
201 struct device *dev = hcd->self.controller; ehci_fsl_setup_phy()
205 dev_warn(hcd->self.controller, "Could not get controller version\n"); ehci_fsl_setup_phy()
252 dev_warn(hcd->self.controller, "USB PHY clock invalid\n"); ehci_fsl_setup_phy()
271 pdata = dev_get_platdata(hcd->self.controller); ehci_fsl_usb_setup()
342 dev = hcd->self.controller; ehci_fsl_setup()
343 pdata = dev_get_platdata(hcd->self.controller); ehci_fsl_setup()
578 usb_root_hub_lost_power(hcd->self.root_hub); ehci_fsl_drv_resume()
593 usb_root_hub_lost_power(hcd->self.root_hub); ehci_fsl_drv_restore()
|
| H A D | ohci-q.c | 44 struct device *dev = ohci_to_hcd(ohci)->self.controller;
58 ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs--;
59 if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {
67 ohci_to_hcd(ohci)->self.bandwidth_int_reqs--;
78 if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0
79 && ohci_to_hcd(ohci)->self.bandwidth_int_reqs == 0) {
177 ohci_to_hcd(ohci)->self.bandwidth_allocated += ed->load / ed->interval; periodic_link()
287 ohci_to_hcd(ohci)->self.bandwidth_allocated -= ed->load / ed->interval; periodic_unlink()
593 struct device *dev = ohci_to_hcd(ohci)->self.controller; td_submit_urb()
645 periodic = ohci_to_hcd(ohci)->self.bandwidth_int_reqs++ == 0 td_submit_urb()
646 && ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0; td_submit_urb()
727 if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) { td_submit_urb()
733 periodic = ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs++ == 0 td_submit_urb()
734 && ohci_to_hcd(ohci)->self.bandwidth_int_reqs == 0; td_submit_urb()
|
| H A D | ehci-hub.c | 169 if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup || do_wakeup) ehci_adjust_port_wakeup_flags()
249 if (hcd->self.root_hub->do_remote_wakeup) { ehci_bus_suspend()
281 if (hcd->self.root_hub->do_remote_wakeup) { ehci_bus_suspend()
357 if (!hcd->self.root_hub->do_remote_wakeup) ehci_bus_suspend()
777 hcd->self.controller, request_single_step_set_feature_urb()
782 hcd->self.controller, request_single_step_set_feature_urb()
801 udev = usb_hub_find_child(hcd->self.root_hub, port); ehset_single_step_set_feature()
924 if ((hcd->self.otg_port == (wIndex + 1)) ehci_hub_control()
925 && hcd->self.b_hnp_enable) { ehci_hub_control()
950 usb_hcd_start_port_resume(&hcd->self, wIndex); ehci_hub_control()
1025 usb_hcd_start_port_resume(&hcd->self, wIndex); ehci_hub_control()
1041 usb_hcd_end_port_resume(&hcd->self, wIndex); ehci_hub_control()
1117 usb_hcd_end_port_resume(&hcd->self, wIndex); ehci_hub_control()
|
| /linux-4.1.27/arch/sh/kernel/cpu/shmobile/ |
| H A D | cpuidle.c | 23 SUSP_SH_SLEEP | SUSP_SH_SF, /* sleep mode + self refresh */
24 SUSP_SH_STANDBY | SUSP_SH_SF, /* software standby mode + self refresh */
|
| H A D | pm.c | 110 /* part 2: board specific code to enter self-refresh mode */ sh_mobile_register_self_refresh()
116 /* part 3: board specific code to resume from self-refresh mode */ sh_mobile_register_self_refresh()
|
| H A D | sleep.S | 27 /* manage self-refresh and enter standby mode. must be self-contained.
149 /* call self-refresh entering code if needed */
285 /* call self-refresh resume code if needed */
|
| /linux-4.1.27/arch/mips/kernel/ |
| H A D | pm.c | 64 * @self: Notifier block.
71 static int mips_pm_notifier(struct notifier_block *self, unsigned long cmd, mips_pm_notifier() argument
|
| H A D | mcount.S | 82 PTR_SUBU a0, ra, 8 /* arg1: self address */
141 move a0, ra /* arg1: self return address */
176 /* arg2: Get self return address */
|
| /linux-4.1.27/arch/arm/mach-prima2/ |
| H A D | sleep.S | 40 @ read the MEM ctl register and set the self
47 @ the RAM is going to self refresh mode
|
| /linux-4.1.27/net/bluetooth/ |
| H A D | selftest.h | 25 /* When CONFIG_BT_SELFTEST=y and the CONFIG_BT=m, then the self testing
32 /* When CONFIG_BT_SELFTEST=y and CONFIG_BT=y, then the self testing
|
| /linux-4.1.27/arch/avr32/mach-at32ap/ |
| H A D | pm-at32ap700x.S | 105 * The SDRAM will be put into self-refresh mode (which does
128 bfins r10, r11, 0, 2 /* LPCB <- self Refresh */
130 st.w r12[SDRAMC_LPR], r10 /* put SDRAM in self-refresh mode */
151 bfins r10, r11, 0, 2 /* LPCB <- self refresh */
152 st.w r12[SDRAMC_LPR], r10 /* put SDRAM in self-refresh mode */
|
| /linux-4.1.27/arch/frv/kernel/ |
| H A D | cmode.S | 26 #define SDRAMC_DSTS_SSI 0x00000001 /* indicates that the SDRAM is in self-refresh mode */
28 #define SDRAMC_DRCN_SR 0x00000001 /* transition SDRAM into self-refresh mode */
118 # self-refresh mode. Execute the dummy load to all memory
145 # instruction that executes the self-loop 256 times. (Meanwhile,
154 # (14) Release the self-refresh of SDRAM.
|
| H A D | sleep.S | 27 #define FR55X_SDRAMC_DSTS_SSI 0x00000002 /* indicates that the SDRAM is in self-refresh mode */
31 #define FR4XX_SDRAMC_DSTS_SSI 0x00000001 /* indicates that the SDRAM is in self-refresh mode */
33 #define SDRAMC_DRCN_SR 0x00000001 /* transition SDRAM into self-refresh mode */
85 # when dram is in self-refresh state.
135 # put SDRAM in self-refresh mode
146 # put the SDRAM into self-refresh mode
152 # wait for SDRAM to reach self-refresh mode
189 # wake SDRAM from self-refresh mode
|
| /linux-4.1.27/arch/arm/mach-pxa/ |
| H A D | sleep.S | 58 @ enable SDRAM self-refresh mode
99 @ enable SDRAM self-refresh mode
159 @ external accesses after SDRAM is put in self-refresh mode
160 @ (see Errata 38 ...hangs when entering self-refresh mode)
165 @ put SDRAM into self-refresh
|
| H A D | reset.c | 87 * we put SDRAM into self-refresh to prevent that do_hw_reset()
|
| /linux-4.1.27/drivers/pci/hotplug/ |
| H A D | sgi_hotplug.c | 248 dev_dbg(&slot->pci_bus->self->dev, "is already active\n"); sn_slot_enable()
253 dev_dbg(&slot->pci_bus->self->dev, "L1 failure %d with message: %s", sn_slot_enable()
259 dev_dbg(&slot->pci_bus->self->dev, "insert failed with error %d sub-error %d\n", sn_slot_enable()
284 dev_dbg(&slot->pci_bus->self->dev, "Slot %s already inactive\n", slot->physical_path); sn_slot_disable()
289 dev_dbg(&slot->pci_bus->self->dev, "Cannot remove last 33MHz card\n"); sn_slot_disable()
294 dev_dbg(&slot->pci_bus->self->dev, "L1 failure %d with message \n%s\n", sn_slot_disable()
300 dev_dbg(&slot->pci_bus->self->dev, "remove failed with error %d sub-error %d\n", sn_slot_disable()
311 dev_dbg(&slot->pci_bus->self->dev, "remove successful\n"); sn_slot_disable()
316 dev_dbg(&slot->pci_bus->self->dev,"remove failed rc = %d\n", rc); sn_slot_disable()
369 dev_dbg(&slot->pci_bus->self->dev, "no device in slot\n"); enable_slot()
415 dev_dbg(&slot->pci_bus->self->dev, "no parent device, assuming NULL\n"); enable_slot()
466 dev_dbg(&slot->pci_bus->self->dev, "insert operation successful\n"); enable_slot()
468 dev_dbg(&slot->pci_bus->self->dev, "insert operation failed rc = %d\n", rc); enable_slot()
646 dev_dbg(&pci_bus->self->dev, "Registered bus with hotplug\n"); sn_hotplug_slot_register()
650 dev_dbg(&pci_bus->self->dev, "bus failed to register with err = %d\n", sn_hotplug_slot_register()
655 dev_dbg(&pci_bus->self->dev, "Memory allocation error\n"); sn_hotplug_slot_register()
688 dev_dbg(&pci_bus->self->dev, "not a valid hotplug bus\n"); sn_pci_hotplug_init()
691 dev_dbg(&pci_bus->self->dev, "valid hotplug bus\n"); sn_pci_hotplug_init()
|
| H A D | rpadlpar_core.c | 367 bus->self ? pci_name(bus->self) : "<!PHB!>"); dlpar_remove_pci_slot()
395 BUG_ON(!bus->self); dlpar_remove_pci_slot()
396 pr_debug("PCI: Now removing bridge device %s\n", pci_name(bus->self)); dlpar_remove_pci_slot()
397 pci_stop_and_remove_bus_device(bus->self); dlpar_remove_pci_slot()
|
| /linux-4.1.27/arch/blackfin/mach-common/ |
| H A D | dpmc_modes.S | 191 /* set the dram to self refresh mode */
197 BITSET(R2, 3); /* SRREQ enter self-refresh mode */
211 BITSET(R2, 24); /* SRFS enter self-refresh mode */
218 cc = BITTST(R2, 1); /* SDSRA poll self-refresh status */
229 /* set the dram out of self refresh mode */
238 /* release CLKOUT from self-refresh */
247 /* release SDRAM from self-refresh */
|
| /linux-4.1.27/arch/x86/platform/intel-quark/ |
| H A D | imr_selftest.c | 7 * IMR self test. The purpose of this module is to run a set of tests on the
23 * imr_self_test_result - Print result string for self test.
136 MODULE_DESCRIPTION("Intel Isolated Memory Region self-test driver");
|
| /linux-4.1.27/arch/powerpc/lib/ |
| H A D | code-patching.c | 195 /* The simplest case, branch to self, no flags */ test_branch_iform()
204 /* Simplest case, branch to self with link */ test_branch_iform()
229 /* Branch to self, with link */ test_branch_iform()
233 /* Branch to self - 0x100, with link */ test_branch_iform()
237 /* Branch to self + 0x100, no link */ test_branch_iform()
283 /* The simplest case, branch to self, no flags */ test_branch_bform()
311 /* Branch to self */ test_branch_bform()
315 /* Branch to self - 0x100 */ test_branch_bform()
319 /* Branch to self + 0x100 */ test_branch_bform()
356 /* Simple case, branch to self moved a little */ test_translate_branch()
406 /* Simple case, branch to self moved a little */ test_translate_branch()
459 printk(KERN_DEBUG "Running code patching self-tests ...\n"); test_code_patching()
|
| /linux-4.1.27/drivers/media/usb/cx231xx/ |
| H A D | cx231xx-pcb-cfg.h | 105 SELF_POWER = 0x0, /* 0: self power */
184 u8 type; /* bus power or self power,
185 self power--0, bus_power--1 */
196 for self-power, always 0 */
|
| /linux-4.1.27/drivers/net/ethernet/sfc/ |
| H A D | selftest.h | 29 /* Efx self test results
|
| /linux-4.1.27/block/ |
| H A D | blk-mq-cpu.c | 21 static int blk_mq_main_cpu_notify(struct notifier_block *self, blk_mq_main_cpu_notify() argument
|
| /linux-4.1.27/arch/sh/kernel/ |
| H A D | nmi_debug.c | 23 static int nmi_debug_notify(struct notifier_block *self, nmi_debug_notify() argument
|
| /linux-4.1.27/include/linux/ |
| H A D | uprobes.h | 49 int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs);
50 int (*ret_handler)(struct uprobe_consumer *self,
53 bool (*filter)(struct uprobe_consumer *self,
128 extern int arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val, void *data);
|
| H A D | pci-acpi.h | 46 if (!pbus->self) acpi_pci_get_bridge_handle()
49 dev = &pbus->self->dev; acpi_pci_get_bridge_handle()
|
| H A D | reset-controller.h | 11 * @reset: for self-deasserting resets, does all necessary
|
| /linux-4.1.27/arch/avr32/include/asm/ |
| H A D | kprobes.h | 44 extern int kprobe_exceptions_notify(struct notifier_block *self,
|
| /linux-4.1.27/arch/alpha/kernel/ |
| H A D | sys_ruffian.c | 151 else if (PCI_SLOT(dev->bus->self->devfn) == 13) { ruffian_swizzle()
158 if (PCI_SLOT(dev->bus->self->devfn) == 13) { ruffian_swizzle()
165 dev = dev->bus->self; ruffian_swizzle()
168 } while (dev->bus->self); ruffian_swizzle()
|
| H A D | sys_miata.c | 208 else if ((PCI_SLOT(dev->bus->self->devfn) == 8) || miata_swizzle()
209 (PCI_SLOT(dev->bus->self->devfn) == 20)) { miata_swizzle()
216 if ((PCI_SLOT(dev->bus->self->devfn) == 8) || miata_swizzle()
217 (PCI_SLOT(dev->bus->self->devfn) == 20)) { miata_swizzle()
224 dev = dev->bus->self; miata_swizzle()
227 } while (dev->bus->self); miata_swizzle()
|
| H A D | sys_nautilus.c | 76 dev->bus->self && dev->bus->self->device == 0x700f) nautilus_map_irq()
217 bus->self = irongate; nautilus_init_pci()
255 /* pci_common_swizzle() relies on bus->self being NULL nautilus_init_pci()
257 bus->self = NULL; nautilus_init_pci()
|
| H A D | sys_eiger.c | 182 while (dev->bus->self) { eiger_swizzle()
185 && (PCI_SLOT(dev->bus->self->devfn) eiger_swizzle()
194 dev = dev->bus->self; eiger_swizzle()
|
| H A D | sys_noritake.c | 233 else if (PCI_SLOT(dev->bus->self->devfn) == 8) { noritake_swizzle()
240 if (PCI_SLOT(dev->bus->self->devfn) == 8) { noritake_swizzle()
247 dev = dev->bus->self; noritake_swizzle()
250 } while (dev->bus->self); noritake_swizzle()
|
| /linux-4.1.27/arch/arc/include/asm/ |
| H A D | kprobes.h | 36 int kprobe_exceptions_notify(struct notifier_block *self,
|
| /linux-4.1.27/arch/blackfin/mach-bf609/ |
| H A D | dpm.S | 91 /* should put ddr to self refresh mode before sleep */
117 /* turn ddr out of self refresh mode */
|
| /linux-4.1.27/arch/arm/mach-mvebu/ |
| H A D | pm-board.c | 59 /* Enter self refresh */ mvebu_armada_xp_gp_pm_enter()
63 * Wait 100 cycles for DDR to enter self refresh, by mvebu_armada_xp_gp_pm_enter()
|
| H A D | kirkwood-pm.c | 34 /* Set DDR in self-refresh */ kirkwood_low_power()
|
| /linux-4.1.27/fs/hpfs/ |
| H A D | map.c | 204 if (le32_to_cpu(anode->self) != ano) { hpfs_map_anode()
205 hpfs_error(s, "self pointer invalid on anode %08x", ano); hpfs_map_anode()
249 if (le32_to_cpu(dnode->self) != secno) hpfs_map_dnode()
250 hpfs_error(s, "bad self pointer on dnode %08x self = %08x", secno, le32_to_cpu(dnode->self)); hpfs_map_dnode()
|
| /linux-4.1.27/drivers/crypto/qat/qat_common/ |
| H A D | adf_accel_devices.h | 139 uint32_t (*get_misc_bar_id)(struct adf_hw_device_data *self);
140 uint32_t (*get_etr_bar_id)(struct adf_hw_device_data *self);
141 uint32_t (*get_num_aes)(struct adf_hw_device_data *self);
142 uint32_t (*get_num_accels)(struct adf_hw_device_data *self);
143 enum dev_sku_info (*get_sku)(struct adf_hw_device_data *self);
|
| /linux-4.1.27/drivers/gpu/drm/mga/ |
| H A D | mga_drv.c | 136 if ((pdev->device == 0x0525) && pdev->bus->self mga_driver_device_is_agp()
137 && (pdev->bus->self->vendor == 0x3388) mga_driver_device_is_agp()
138 && (pdev->bus->self->device == 0x0021)) { mga_driver_device_is_agp()
|
| /linux-4.1.27/arch/tile/kernel/ |
| H A D | mcount_64.S | 82 /* arg1: self return address */
165 /* arg1: self return address */
191 /* arg2: Get self return address */
|
| /linux-4.1.27/arch/powerpc/sysdev/ |
| H A D | mpic_u3msi.c | 71 for (bus = pdev->bus; bus && bus->self; bus = bus->parent) { find_ht_magic_addr()
72 pos = pci_find_ht_capability(bus->self, HT_CAPTYPE_MSI_MAPPING); find_ht_magic_addr()
74 return read_ht_magic_addr(bus->self, pos); find_ht_magic_addr()
|
| H A D | xilinx_pci.c | 43 if (dev->devfn || dev->bus->self) xilinx_pci_fixup_bridge()
110 * a self-init when the bus master enable bit is set. Without this bit xilinx_pci_init()
|
| /linux-4.1.27/arch/arm/mach-omap2/ |
| H A D | sleep24xx.S | 73 orr r4, r4, #0x40 @ enable self refresh on idle req
83 /* The DPLL has to be on before we take the DDR out of self refresh */
84 bic r4, r4, #0x40 @ now clear self refresh bit.
|
| /linux-4.1.27/drivers/staging/iio/accel/ |
| H A D | adis16220.h | 50 /* Control, self-test control, AIN configuration */
60 /* Status, self-test response */
|
| H A D | adis16240.h | 98 /* Power-on, self-test flag: 1 = failure, 0 = pass */
100 /* Power-on self-test: 1 = in-progress, 0 = complete */
|
| /linux-4.1.27/arch/powerpc/platforms/52xx/ |
| H A D | mpc52xx_sleep.S | 67 /* put SDRAM into self-refresh */
110 /* get ram out of self-refresh */
|
| H A D | lite5200_sleep.S | 59 * WARNING: self-refresh doesn't seem to work when BDI2000 is connected,
107 /* self refresh */
129 * mode_en must not be set when enabling self-refresh
130 * send AR with CKE low (self-refresh)
|
| /linux-4.1.27/arch/arm/kernel/ |
| H A D | xscale-cp0.c | 33 static int dsp_do(struct notifier_block *self, unsigned long cmd, void *t) dsp_do() argument
58 static int iwmmxt_do(struct notifier_block *self, unsigned long cmd, void *t) iwmmxt_do() argument
|
| H A D | thumbee.c | 42 static int thumbee_notifier(struct notifier_block *self, unsigned long cmd, void *t) thumbee_notifier() argument
|
| /linux-4.1.27/drivers/macintosh/ |
| H A D | windfarm_cpufreq_clamp.c | 19 static int clamp_notifier_call(struct notifier_block *self, clamp_notifier_call() argument
|
| /linux-4.1.27/drivers/media/usb/pvrusb2/ |
| H A D | pvrusb2-debugifc.h | 27 driver so the information should be self-consistent (but it will
|
| /linux-4.1.27/drivers/oprofile/ |
| H A D | timer_int.c | 77 static int oprofile_cpu_notify(struct notifier_block *self, oprofile_cpu_notify() argument
|
| /linux-4.1.27/drivers/clocksource/ |
| H A D | dummy_timer.c | 44 static int dummy_timer_cpu_notify(struct notifier_block *self, dummy_timer_cpu_notify() argument
|
| /linux-4.1.27/arch/sparc/oprofile/ |
| H A D | init.c | 22 static int profile_timer_exceptions_notify(struct notifier_block *self, profile_timer_exceptions_notify() argument
|
| /linux-4.1.27/arch/tile/include/asm/ |
| H A D | kprobes.h | 76 extern int kprobe_exceptions_notify(struct notifier_block *self,
|
| H A D | linkage.h | 24 * self-named .text.foo section, and if linker feedback collection
|
| /linux-4.1.27/drivers/usb/wusbcore/ |
| H A D | pal.c | 41 wusbhc->pal.device = wusbhc->usb_hcd.self.controller; wusbhc_pal_register()
|
| /linux-4.1.27/arch/mn10300/include/asm/ |
| H A D | kprobes.h | 43 extern int kprobe_exceptions_notify(struct notifier_block *self,
|
| /linux-4.1.27/arch/mn10300/kernel/ |
| H A D | irq.c | 313 unsigned int self, new; migrate_irqs() local
316 self = smp_processor_id(); migrate_irqs()
323 if (cpumask_test_cpu(self, &data->affinity) && migrate_irqs()
331 if (irq_affinity_online[irq] == self) { migrate_irqs()
|
| /linux-4.1.27/arch/powerpc/kernel/ |
| H A D | pci_64.c | 92 if (bus->self) { pcibios_unmap_io_space()
98 pci_name(bus->self)); pcibios_unmap_io_space()
182 if (bus->self) { pcibios_map_io_space()
184 pci_name(bus->self)); pcibios_map_io_space()
|
| /linux-4.1.27/arch/avr32/kernel/ |
| H A D | nmi_debug.c | 24 static int nmi_debug_notify(struct notifier_block *self, nmi_debug_notify() argument
|
| /linux-4.1.27/arch/m32r/include/asm/ |
| H A D | rtc.h | 44 * source is self contained, allowing cross-compiles, etc. etc.
|
| /linux-4.1.27/arch/arm/mach-tegra/ |
| H A D | irq.c | 53 static int tegra_gic_notifier(struct notifier_block *self, tegra_gic_notifier() argument
|
| /linux-4.1.27/arch/arm/mach-ep93xx/ |
| H A D | crunch.c | 39 static int crunch_do(struct notifier_block *self, unsigned long cmd, void *t) crunch_do() argument
|
| /linux-4.1.27/lib/ |
| H A D | random32.c | 434 pr_warn("prandom: seed boundary self test failed\n"); prandom_state_selftest()
436 pr_info("prandom: seed boundary self test passed\n"); prandom_state_selftest()
455 pr_warn("prandom: %d/%d self tests failed\n", errors, runs); prandom_state_selftest()
457 pr_info("prandom: %d self tests passed\n", runs); prandom_state_selftest()
|
| /linux-4.1.27/tools/testing/selftests/kcmp/ |
| H A D | kcmp_test.c | 86 /* Compare with self */ main()
|
| /linux-4.1.27/tools/testing/selftests/vm/ |
| H A D | hugetlbfstest.c | 22 fd = open("/proc/self/statm", O_RDONLY); read_rss()
|
| /linux-4.1.27/drivers/iio/imu/ |
| H A D | adis16480.c | 789 [ADIS16480_DIAG_STAT_XGYRO_FAIL] = "X-axis gyroscope self-test failure",
790 [ADIS16480_DIAG_STAT_YGYRO_FAIL] = "Y-axis gyroscope self-test failure",
791 [ADIS16480_DIAG_STAT_ZGYRO_FAIL] = "Z-axis gyroscope self-test failure",
792 [ADIS16480_DIAG_STAT_XACCL_FAIL] = "X-axis accelerometer self-test failure",
793 [ADIS16480_DIAG_STAT_YACCL_FAIL] = "Y-axis accelerometer self-test failure",
794 [ADIS16480_DIAG_STAT_ZACCL_FAIL] = "Z-axis accelerometer self-test failure",
795 [ADIS16480_DIAG_STAT_XMAGN_FAIL] = "X-axis magnetometer self-test failure",
796 [ADIS16480_DIAG_STAT_YMAGN_FAIL] = "Y-axis magnetometer self-test failure",
797 [ADIS16480_DIAG_STAT_ZMAGN_FAIL] = "Z-axis magnetometer self-test failure",
798 [ADIS16480_DIAG_STAT_BARO_FAIL] = "Barometer self-test failure",
|
| /linux-4.1.27/drivers/firewire/ |
| H A D | core-topology.c | 88 * extended self ID packets and that the count_ports()
89 * sequence numbers in the extended self ID count_ports()
178 * by the self IDs from the latest bus reset. During the construction
179 * of the tree, the function checks that the self IDs are valid and
207 fw_err(card, "inconsistent extended self IDs\n"); build_tree()
213 fw_err(card, "PHY ID mismatch in self ID: %d != %d\n", build_tree()
|
| /linux-4.1.27/arch/m68k/atari/ |
| H A D | atakeyb.c | 46 /* variables for IKBD self test: */
155 /* During self test, don't do resyncing, just process the code */ atari_keyboard_interrupt()
204 /* during self-test, note that 0xf1 received */ atari_keyboard_interrupt()
216 /* Scancodes sent during the self-test stand for broken atari_keyboard_interrupt()
550 * self-test is finished */ atari_keyb_init()
556 printk(KERN_ERR "WARNING: keyboard self test failed!\n"); atari_keyb_init()
|