Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit fcb261f35714fdf3d5c37d714e55b507b8cd55bc

Authored by Joe Perches
Committed by David S. Miller
1 parent 207ec0abbe
Exists in master and in 20 other branches dlt-processor-sdk-linux-03.00.00.04, newt-ti-linux-3.12.y, processor-sdk-linux-01.00.00, processor-sdk-linux-02.00.01, smarc-ti-linux-3.12.10, smarc-ti-linux-3.12.y, smarc-ti-linux-3.14.y, smarc-ti-linux-3.15.y, smarc-ti-lsk-linux-4.1.y, smarct3x-processor-sdk-04.01.00.06, smarct3x-processor-sdk-linux-02.00.01, smarct3x-processor-sdk-linux-03.00.00.04, smarct4x-800-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-04.01.00.06, smarct4x-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-linux-03.00.00.04, ti-linux-3.12.y, ti-linux-3.14.y, ti-linux-3.15.y, ti-lsk-linux-4.1.y

lapb: Reduce switch/case indent 

Make the case labels the same indent as the switch.

git diff -w shows 80 column reflowing.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 2 changed files with 444 additions and 467 deletions Side-by-side Diff

net/lapb/lapb_iface.c
Diff comments   View file @ fcb261f
... ... @@ -300,26 +300,26 @@
300 300 goto out;
301 301  
302 302 switch (lapb->state) {
303   - case LAPB_STATE_0:
304   - rc = LAPB_NOTCONNECTED;
305   - goto out_put;
  303 + case LAPB_STATE_0:
  304 + rc = LAPB_NOTCONNECTED;
  305 + goto out_put;
306 306  
307   - case LAPB_STATE_1:
  307 + case LAPB_STATE_1:
308 308 #if LAPB_DEBUG > 1
309   - printk(KERN_DEBUG "lapb: (%p) S1 TX DISC(1)\n", lapb->dev);
  309 + printk(KERN_DEBUG "lapb: (%p) S1 TX DISC(1)\n", lapb->dev);
310 310 #endif
311 311 #if LAPB_DEBUG > 0
312   - printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->dev);
  312 + printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->dev);
313 313 #endif
314   - lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
315   - lapb->state = LAPB_STATE_0;
316   - lapb_start_t1timer(lapb);
317   - rc = LAPB_NOTCONNECTED;
318   - goto out_put;
  314 + lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
  315 + lapb->state = LAPB_STATE_0;
  316 + lapb_start_t1timer(lapb);
  317 + rc = LAPB_NOTCONNECTED;
  318 + goto out_put;
319 319  
320   - case LAPB_STATE_2:
321   - rc = LAPB_OK;
322   - goto out_put;
  320 + case LAPB_STATE_2:
  321 + rc = LAPB_OK;
  322 + goto out_put;
323 323 }
324 324  
325 325 lapb_clear_queues(lapb);
Changes suppressed. Click to show
... ... @@ -44,89 +44,86 @@
44 44 struct lapb_frame *frame)
45 45 {
46 46 switch (frame->type) {
47   - case LAPB_SABM:
  47 + case LAPB_SABM:
48 48 #if LAPB_DEBUG > 1
49   - printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n",
50   - lapb->dev, frame->pf);
  49 + printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n",
  50 + lapb->dev, frame->pf);
51 51 #endif
52   - if (lapb->mode & LAPB_EXTENDED) {
  52 + if (lapb->mode & LAPB_EXTENDED) {
53 53 #if LAPB_DEBUG > 1
54   - printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
55   - lapb->dev, frame->pf);
  54 + printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
  55 + lapb->dev, frame->pf);
56 56 #endif
57   - lapb_send_control(lapb, LAPB_DM, frame->pf,
58   - LAPB_RESPONSE);
59   - } else {
  57 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  58 + LAPB_RESPONSE);
  59 + } else {
60 60 #if LAPB_DEBUG > 1
61   - printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
62   - lapb->dev, frame->pf);
  61 + printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  62 + lapb->dev, frame->pf);
63 63 #endif
64 64 #if LAPB_DEBUG > 0
65   - printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
66   - lapb->dev);
  65 + printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->dev);
67 66 #endif
68   - lapb_send_control(lapb, LAPB_UA, frame->pf,
69   - LAPB_RESPONSE);
70   - lapb_stop_t1timer(lapb);
71   - lapb_stop_t2timer(lapb);
72   - lapb->state = LAPB_STATE_3;
73   - lapb->condition = 0x00;
74   - lapb->n2count = 0;
75   - lapb->vs = 0;
76   - lapb->vr = 0;
77   - lapb->va = 0;
78   - lapb_connect_indication(lapb, LAPB_OK);
79   - }
80   - break;
  67 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  68 + LAPB_RESPONSE);
  69 + lapb_stop_t1timer(lapb);
  70 + lapb_stop_t2timer(lapb);
  71 + lapb->state = LAPB_STATE_3;
  72 + lapb->condition = 0x00;
  73 + lapb->n2count = 0;
  74 + lapb->vs = 0;
  75 + lapb->vr = 0;
  76 + lapb->va = 0;
  77 + lapb_connect_indication(lapb, LAPB_OK);
  78 + }
  79 + break;
81 80  
82   - case LAPB_SABME:
  81 + case LAPB_SABME:
83 82 #if LAPB_DEBUG > 1
84   - printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
85   - lapb->dev, frame->pf);
  83 + printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
  84 + lapb->dev, frame->pf);
86 85 #endif
87   - if (lapb->mode & LAPB_EXTENDED) {
  86 + if (lapb->mode & LAPB_EXTENDED) {
88 87 #if LAPB_DEBUG > 1
89   - printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
90   - lapb->dev, frame->pf);
  88 + printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  89 + lapb->dev, frame->pf);
91 90 #endif
92 91 #if LAPB_DEBUG > 0
93   - printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
94   - lapb->dev);
  92 + printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->dev);
95 93 #endif
96   - lapb_send_control(lapb, LAPB_UA, frame->pf,
97   - LAPB_RESPONSE);
98   - lapb_stop_t1timer(lapb);
99   - lapb_stop_t2timer(lapb);
100   - lapb->state = LAPB_STATE_3;
101   - lapb->condition = 0x00;
102   - lapb->n2count = 0;
103   - lapb->vs = 0;
104   - lapb->vr = 0;
105   - lapb->va = 0;
106   - lapb_connect_indication(lapb, LAPB_OK);
107   - } else {
  94 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  95 + LAPB_RESPONSE);
  96 + lapb_stop_t1timer(lapb);
  97 + lapb_stop_t2timer(lapb);
  98 + lapb->state = LAPB_STATE_3;
  99 + lapb->condition = 0x00;
  100 + lapb->n2count = 0;
  101 + lapb->vs = 0;
  102 + lapb->vr = 0;
  103 + lapb->va = 0;
  104 + lapb_connect_indication(lapb, LAPB_OK);
  105 + } else {
108 106 #if LAPB_DEBUG > 1
109   - printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
110   - lapb->dev, frame->pf);
  107 + printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
  108 + lapb->dev, frame->pf);
111 109 #endif
112   - lapb_send_control(lapb, LAPB_DM, frame->pf,
113   - LAPB_RESPONSE);
114   - }
115   - break;
  110 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  111 + LAPB_RESPONSE);
  112 + }
  113 + break;
116 114  
117   - case LAPB_DISC:
  115 + case LAPB_DISC:
118 116 #if LAPB_DEBUG > 1
119   - printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n",
120   - lapb->dev, frame->pf);
121   - printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
122   - lapb->dev, frame->pf);
  117 + printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n",
  118 + lapb->dev, frame->pf);
  119 + printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  120 + lapb->dev, frame->pf);
123 121 #endif
124   - lapb_send_control(lapb, LAPB_UA, frame->pf,
125   - LAPB_RESPONSE);
126   - break;
  122 + lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
  123 + break;
127 124  
128   - default:
129   - break;
  125 + default:
  126 + break;
130 127 }
131 128  
132 129 kfree_skb(skb);
133 130  
134 131  
135 132  
136 133  
137 134  
138 135  
139 136  
140 137  
141 138  
142 139  
143 140  
144 141  
145 142  
146 143  
147 144  
148 145  
149 146  
150 147  
151 148  
152 149  
153 150  
154 151  
155 152  
... ... @@ -140,100 +137,97 @@
140 137 struct lapb_frame *frame)
141 138 {
142 139 switch (frame->type) {
143   - case LAPB_SABM:
  140 + case LAPB_SABM:
144 141 #if LAPB_DEBUG > 1
145   - printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
146   - lapb->dev, frame->pf);
  142 + printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
  143 + lapb->dev, frame->pf);
147 144 #endif
148   - if (lapb->mode & LAPB_EXTENDED) {
  145 + if (lapb->mode & LAPB_EXTENDED) {
149 146 #if LAPB_DEBUG > 1
150   - printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
151   - lapb->dev, frame->pf);
  147 + printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
  148 + lapb->dev, frame->pf);
152 149 #endif
153   - lapb_send_control(lapb, LAPB_DM, frame->pf,
154   - LAPB_RESPONSE);
155   - } else {
  150 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  151 + LAPB_RESPONSE);
  152 + } else {
156 153 #if LAPB_DEBUG > 1
157   - printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
158   - lapb->dev, frame->pf);
  154 + printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
  155 + lapb->dev, frame->pf);
159 156 #endif
160   - lapb_send_control(lapb, LAPB_UA, frame->pf,
161   - LAPB_RESPONSE);
162   - }
163   - break;
  157 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  158 + LAPB_RESPONSE);
  159 + }
  160 + break;
164 161  
165   - case LAPB_SABME:
  162 + case LAPB_SABME:
166 163 #if LAPB_DEBUG > 1
167   - printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
168   - lapb->dev, frame->pf);
  164 + printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
  165 + lapb->dev, frame->pf);
169 166 #endif
170   - if (lapb->mode & LAPB_EXTENDED) {
  167 + if (lapb->mode & LAPB_EXTENDED) {
171 168 #if LAPB_DEBUG > 1
172   - printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
173   - lapb->dev, frame->pf);
  169 + printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
  170 + lapb->dev, frame->pf);
174 171 #endif
175   - lapb_send_control(lapb, LAPB_UA, frame->pf,
176   - LAPB_RESPONSE);
177   - } else {
  172 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  173 + LAPB_RESPONSE);
  174 + } else {
178 175 #if LAPB_DEBUG > 1
179   - printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
180   - lapb->dev, frame->pf);
181   -#endif
182   - lapb_send_control(lapb, LAPB_DM, frame->pf,
183   - LAPB_RESPONSE);
184   - }
185   - break;
186   -
187   - case LAPB_DISC:
188   -#if LAPB_DEBUG > 1
189   - printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n",
190   - lapb->dev, frame->pf);
191 176 printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
192 177 lapb->dev, frame->pf);
193 178 #endif
194 179 lapb_send_control(lapb, LAPB_DM, frame->pf,
195 180 LAPB_RESPONSE);
196   - break;
  181 + }
  182 + break;
197 183  
198   - case LAPB_UA:
  184 + case LAPB_DISC:
199 185 #if LAPB_DEBUG > 1
200   - printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
201   - lapb->dev, frame->pf);
  186 + printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n",
  187 + lapb->dev, frame->pf);
  188 + printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
  189 + lapb->dev, frame->pf);
202 190 #endif
203   - if (frame->pf) {
  191 + lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
  192 + break;
  193 +
  194 + case LAPB_UA:
  195 +#if LAPB_DEBUG > 1
  196 + printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
  197 + lapb->dev, frame->pf);
  198 +#endif
  199 + if (frame->pf) {
204 200 #if LAPB_DEBUG > 0
205   - printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n",
206   - lapb->dev);
  201 + printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n", lapb->dev);
207 202 #endif
208   - lapb_stop_t1timer(lapb);
209   - lapb_stop_t2timer(lapb);
210   - lapb->state = LAPB_STATE_3;
211   - lapb->condition = 0x00;
212   - lapb->n2count = 0;
213   - lapb->vs = 0;
214   - lapb->vr = 0;
215   - lapb->va = 0;
216   - lapb_connect_confirmation(lapb, LAPB_OK);
217   - }
218   - break;
  203 + lapb_stop_t1timer(lapb);
  204 + lapb_stop_t2timer(lapb);
  205 + lapb->state = LAPB_STATE_3;
  206 + lapb->condition = 0x00;
  207 + lapb->n2count = 0;
  208 + lapb->vs = 0;
  209 + lapb->vr = 0;
  210 + lapb->va = 0;
  211 + lapb_connect_confirmation(lapb, LAPB_OK);
  212 + }
  213 + break;
219 214  
220   - case LAPB_DM:
  215 + case LAPB_DM:
221 216 #if LAPB_DEBUG > 1
222   - printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n",
223   - lapb->dev, frame->pf);
  217 + printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n",
  218 + lapb->dev, frame->pf);
224 219 #endif
225   - if (frame->pf) {
  220 + if (frame->pf) {
226 221 #if LAPB_DEBUG > 0
227   - printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n",
228   - lapb->dev);
  222 + printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->dev);
229 223 #endif
230   - lapb_clear_queues(lapb);
231   - lapb->state = LAPB_STATE_0;
232   - lapb_start_t1timer(lapb);
233   - lapb_stop_t2timer(lapb);
234   - lapb_disconnect_indication(lapb, LAPB_REFUSED);
235   - }
236   - break;
  224 + lapb_clear_queues(lapb);
  225 + lapb->state = LAPB_STATE_0;
  226 + lapb_start_t1timer(lapb);
  227 + lapb_stop_t2timer(lapb);
  228 + lapb_disconnect_indication(lapb, LAPB_REFUSED);
  229 + }
  230 + break;
237 231 }
238 232  
239 233 kfree_skb(skb);
240 234  
241 235  
242 236  
243 237  
244 238  
245 239  
246 240  
247 241  
248 242  
249 243  
250 244  
251 245  
252 246  
253 247  
254 248  
255 249  
256 250  
257 251  
... ... @@ -247,78 +241,73 @@
247 241 struct lapb_frame *frame)
248 242 {
249 243 switch (frame->type) {
250   - case LAPB_SABM:
251   - case LAPB_SABME:
  244 + case LAPB_SABM:
  245 + case LAPB_SABME:
252 246 #if LAPB_DEBUG > 1
253   - printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n",
254   - lapb->dev, frame->pf);
255   - printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n",
256   - lapb->dev, frame->pf);
  247 + printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n",
  248 + lapb->dev, frame->pf);
  249 + printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n",
  250 + lapb->dev, frame->pf);
257 251 #endif
258   - lapb_send_control(lapb, LAPB_DM, frame->pf,
259   - LAPB_RESPONSE);
260   - break;
  252 + lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
  253 + break;
261 254  
262   - case LAPB_DISC:
  255 + case LAPB_DISC:
263 256 #if LAPB_DEBUG > 1
264   - printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n",
265   - lapb->dev, frame->pf);
266   - printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n",
267   - lapb->dev, frame->pf);
  257 + printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n",
  258 + lapb->dev, frame->pf);
  259 + printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n",
  260 + lapb->dev, frame->pf);
268 261 #endif
269   - lapb_send_control(lapb, LAPB_UA, frame->pf,
270   - LAPB_RESPONSE);
271   - break;
  262 + lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
  263 + break;
272 264  
273   - case LAPB_UA:
  265 + case LAPB_UA:
274 266 #if LAPB_DEBUG > 1
275   - printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
276   - lapb->dev, frame->pf);
  267 + printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
  268 + lapb->dev, frame->pf);
277 269 #endif
278   - if (frame->pf) {
  270 + if (frame->pf) {
279 271 #if LAPB_DEBUG > 0
280   - printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
281   - lapb->dev);
  272 + printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->dev);
282 273 #endif
283   - lapb->state = LAPB_STATE_0;
284   - lapb_start_t1timer(lapb);
285   - lapb_stop_t2timer(lapb);
286   - lapb_disconnect_confirmation(lapb, LAPB_OK);
287   - }
288   - break;
  274 + lapb->state = LAPB_STATE_0;
  275 + lapb_start_t1timer(lapb);
  276 + lapb_stop_t2timer(lapb);
  277 + lapb_disconnect_confirmation(lapb, LAPB_OK);
  278 + }
  279 + break;
289 280  
290   - case LAPB_DM:
  281 + case LAPB_DM:
291 282 #if LAPB_DEBUG > 1
292   - printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
293   - lapb->dev, frame->pf);
  283 + printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
  284 + lapb->dev, frame->pf);
294 285 #endif
295   - if (frame->pf) {
  286 + if (frame->pf) {
296 287 #if LAPB_DEBUG > 0
297   - printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
298   - lapb->dev);
  288 + printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->dev);
299 289 #endif
300   - lapb->state = LAPB_STATE_0;
301   - lapb_start_t1timer(lapb);
302   - lapb_stop_t2timer(lapb);
303   - lapb_disconnect_confirmation(lapb,
304   - LAPB_NOTCONNECTED);
305   - }
306   - break;
  290 + lapb->state = LAPB_STATE_0;
  291 + lapb_start_t1timer(lapb);
  292 + lapb_stop_t2timer(lapb);
  293 + lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED);
  294 + }
  295 + break;
307 296  
308   - case LAPB_I:
309   - case LAPB_REJ:
310   - case LAPB_RNR:
311   - case LAPB_RR:
  297 + case LAPB_I:
  298 + case LAPB_REJ:
  299 + case LAPB_RNR:
  300 + case LAPB_RR:
312 301 #if LAPB_DEBUG > 1
313   - printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}"
314   - "(%d)\n", lapb->dev, frame->pf);
315   - printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
316   - lapb->dev, frame->pf);
  302 + printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}(%d)\n",
  303 + lapb->dev, frame->pf);
  304 + printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
  305 + lapb->dev, frame->pf);
317 306 #endif
318   - if (frame->pf)
319   - lapb_send_control(lapb, LAPB_DM, frame->pf,
320   - LAPB_RESPONSE);
321   - break;
  307 + if (frame->pf)
  308 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  309 + LAPB_RESPONSE);
  310 + break;
322 311 }
323 312  
324 313 kfree_skb(skb);
325 314  
326 315  
327 316  
328 317  
329 318  
330 319  
331 320  
332 321  
333 322  
334 323  
335 324  
336 325  
337 326  
338 327  
339 328  
340 329  
341 330  
342 331  
343 332  
344 333  
345 334  
346 335  
347 336  
348 337  
349 338  
350 339  
351 340  
352 341  
353 342  
354 343  
355 344  
356 345  
357 346  
358 347  
359 348  
360 349  
361 350  
362 351  
363 352  
364 353  
365 354  
366 355  
367 356  
368 357  
369 358  
370 359  
371 360  
372 361  
373 362  
374 363  
375 364  
376 365  
377 366  
378 367  
379 368  
380 369  
381 370  
382 371  
... ... @@ -336,277 +325,267 @@
336 325 LAPB_SMODULUS;
337 326  
338 327 switch (frame->type) {
339   - case LAPB_SABM:
  328 + case LAPB_SABM:
340 329 #if LAPB_DEBUG > 1
341   - printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
342   - lapb->dev, frame->pf);
  330 + printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
  331 + lapb->dev, frame->pf);
343 332 #endif
344   - if (lapb->mode & LAPB_EXTENDED) {
  333 + if (lapb->mode & LAPB_EXTENDED) {
345 334 #if LAPB_DEBUG > 1
346   - printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
347   - lapb->dev, frame->pf);
  335 + printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
  336 + lapb->dev, frame->pf);
348 337 #endif
349   - lapb_send_control(lapb, LAPB_DM, frame->pf,
350   - LAPB_RESPONSE);
351   - } else {
  338 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  339 + LAPB_RESPONSE);
  340 + } else {
352 341 #if LAPB_DEBUG > 1
353   - printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
354   - lapb->dev, frame->pf);
  342 + printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
  343 + lapb->dev, frame->pf);
355 344 #endif
356   - lapb_send_control(lapb, LAPB_UA, frame->pf,
357   - LAPB_RESPONSE);
358   - lapb_stop_t1timer(lapb);
359   - lapb_stop_t2timer(lapb);
360   - lapb->condition = 0x00;
361   - lapb->n2count = 0;
362   - lapb->vs = 0;
363   - lapb->vr = 0;
364   - lapb->va = 0;
365   - lapb_requeue_frames(lapb);
366   - }
367   - break;
  345 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  346 + LAPB_RESPONSE);
  347 + lapb_stop_t1timer(lapb);
  348 + lapb_stop_t2timer(lapb);
  349 + lapb->condition = 0x00;
  350 + lapb->n2count = 0;
  351 + lapb->vs = 0;
  352 + lapb->vr = 0;
  353 + lapb->va = 0;
  354 + lapb_requeue_frames(lapb);
  355 + }
  356 + break;
368 357  
369   - case LAPB_SABME:
  358 + case LAPB_SABME:
370 359 #if LAPB_DEBUG > 1
371   - printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
372   - lapb->dev, frame->pf);
  360 + printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
  361 + lapb->dev, frame->pf);
373 362 #endif
374   - if (lapb->mode & LAPB_EXTENDED) {
  363 + if (lapb->mode & LAPB_EXTENDED) {
375 364 #if LAPB_DEBUG > 1
376   - printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
377   - lapb->dev, frame->pf);
  365 + printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
  366 + lapb->dev, frame->pf);
378 367 #endif
379   - lapb_send_control(lapb, LAPB_UA, frame->pf,
380   - LAPB_RESPONSE);
381   - lapb_stop_t1timer(lapb);
382   - lapb_stop_t2timer(lapb);
383   - lapb->condition = 0x00;
384   - lapb->n2count = 0;
385   - lapb->vs = 0;
386   - lapb->vr = 0;
387   - lapb->va = 0;
388   - lapb_requeue_frames(lapb);
389   - } else {
  368 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  369 + LAPB_RESPONSE);
  370 + lapb_stop_t1timer(lapb);
  371 + lapb_stop_t2timer(lapb);
  372 + lapb->condition = 0x00;
  373 + lapb->n2count = 0;
  374 + lapb->vs = 0;
  375 + lapb->vr = 0;
  376 + lapb->va = 0;
  377 + lapb_requeue_frames(lapb);
  378 + } else {
390 379 #if LAPB_DEBUG > 1
391   - printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
392   - lapb->dev, frame->pf);
  380 + printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
  381 + lapb->dev, frame->pf);
393 382 #endif
394   - lapb_send_control(lapb, LAPB_DM, frame->pf,
395   - LAPB_RESPONSE);
396   - }
397   - break;
  383 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  384 + LAPB_RESPONSE);
  385 + }
  386 + break;
398 387  
399   - case LAPB_DISC:
  388 + case LAPB_DISC:
400 389 #if LAPB_DEBUG > 1
401   - printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
402   - lapb->dev, frame->pf);
  390 + printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
  391 + lapb->dev, frame->pf);
403 392 #endif
404 393 #if LAPB_DEBUG > 0
405   - printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
406   - lapb->dev);
  394 + printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->dev);
407 395 #endif
408   - lapb_clear_queues(lapb);
409   - lapb_send_control(lapb, LAPB_UA, frame->pf,
410   - LAPB_RESPONSE);
411   - lapb_start_t1timer(lapb);
412   - lapb_stop_t2timer(lapb);
413   - lapb->state = LAPB_STATE_0;
414   - lapb_disconnect_indication(lapb, LAPB_OK);
415   - break;
  396 + lapb_clear_queues(lapb);
  397 + lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
  398 + lapb_start_t1timer(lapb);
  399 + lapb_stop_t2timer(lapb);
  400 + lapb->state = LAPB_STATE_0;
  401 + lapb_disconnect_indication(lapb, LAPB_OK);
  402 + break;
416 403  
417   - case LAPB_DM:
  404 + case LAPB_DM:
418 405 #if LAPB_DEBUG > 1
419   - printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
420   - lapb->dev, frame->pf);
  406 + printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
  407 + lapb->dev, frame->pf);
421 408 #endif
422 409 #if LAPB_DEBUG > 0
423   - printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
424   - lapb->dev);
  410 + printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->dev);
425 411 #endif
426   - lapb_clear_queues(lapb);
427   - lapb->state = LAPB_STATE_0;
428   - lapb_start_t1timer(lapb);
429   - lapb_stop_t2timer(lapb);
430   - lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
431   - break;
  412 + lapb_clear_queues(lapb);
  413 + lapb->state = LAPB_STATE_0;
  414 + lapb_start_t1timer(lapb);
  415 + lapb_stop_t2timer(lapb);
  416 + lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
  417 + break;
432 418  
433   - case LAPB_RNR:
  419 + case LAPB_RNR:
434 420 #if LAPB_DEBUG > 1
435   - printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
436   - lapb->dev, frame->pf, frame->nr);
  421 + printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
  422 + lapb->dev, frame->pf, frame->nr);
437 423 #endif
438   - lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
439   - lapb_check_need_response(lapb, frame->cr, frame->pf);
440   - if (lapb_validate_nr(lapb, frame->nr)) {
441   - lapb_check_iframes_acked(lapb, frame->nr);
442   - } else {
443   - lapb->frmr_data = *frame;
444   - lapb->frmr_type = LAPB_FRMR_Z;
445   - lapb_transmit_frmr(lapb);
  424 + lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
  425 + lapb_check_need_response(lapb, frame->cr, frame->pf);
  426 + if (lapb_validate_nr(lapb, frame->nr)) {
  427 + lapb_check_iframes_acked(lapb, frame->nr);
  428 + } else {
  429 + lapb->frmr_data = *frame;
  430 + lapb->frmr_type = LAPB_FRMR_Z;
  431 + lapb_transmit_frmr(lapb);
446 432 #if LAPB_DEBUG > 0
447   - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
448   - lapb->dev);
  433 + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
449 434 #endif
450   - lapb_start_t1timer(lapb);
451   - lapb_stop_t2timer(lapb);
452   - lapb->state = LAPB_STATE_4;
453   - lapb->n2count = 0;
454   - }
455   - break;
  435 + lapb_start_t1timer(lapb);
  436 + lapb_stop_t2timer(lapb);
  437 + lapb->state = LAPB_STATE_4;
  438 + lapb->n2count = 0;
  439 + }
  440 + break;
456 441  
457   - case LAPB_RR:
  442 + case LAPB_RR:
458 443 #if LAPB_DEBUG > 1
459   - printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
460   - lapb->dev, frame->pf, frame->nr);
  444 + printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
  445 + lapb->dev, frame->pf, frame->nr);
461 446 #endif
462   - lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
463   - lapb_check_need_response(lapb, frame->cr, frame->pf);
464   - if (lapb_validate_nr(lapb, frame->nr)) {
465   - lapb_check_iframes_acked(lapb, frame->nr);
466   - } else {
467   - lapb->frmr_data = *frame;
468   - lapb->frmr_type = LAPB_FRMR_Z;
469   - lapb_transmit_frmr(lapb);
  447 + lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
  448 + lapb_check_need_response(lapb, frame->cr, frame->pf);
  449 + if (lapb_validate_nr(lapb, frame->nr)) {
  450 + lapb_check_iframes_acked(lapb, frame->nr);
  451 + } else {
  452 + lapb->frmr_data = *frame;
  453 + lapb->frmr_type = LAPB_FRMR_Z;
  454 + lapb_transmit_frmr(lapb);
470 455 #if LAPB_DEBUG > 0
471   - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
472   - lapb->dev);
  456 + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
473 457 #endif
474   - lapb_start_t1timer(lapb);
475   - lapb_stop_t2timer(lapb);
476   - lapb->state = LAPB_STATE_4;
477   - lapb->n2count = 0;
478   - }
479   - break;
  458 + lapb_start_t1timer(lapb);
  459 + lapb_stop_t2timer(lapb);
  460 + lapb->state = LAPB_STATE_4;
  461 + lapb->n2count = 0;
  462 + }
  463 + break;
480 464  
481   - case LAPB_REJ:
  465 + case LAPB_REJ:
482 466 #if LAPB_DEBUG > 1
483   - printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
484   - lapb->dev, frame->pf, frame->nr);
  467 + printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
  468 + lapb->dev, frame->pf, frame->nr);
485 469 #endif
486   - lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
487   - lapb_check_need_response(lapb, frame->cr, frame->pf);
488   - if (lapb_validate_nr(lapb, frame->nr)) {
489   - lapb_frames_acked(lapb, frame->nr);
490   - lapb_stop_t1timer(lapb);
491   - lapb->n2count = 0;
492   - lapb_requeue_frames(lapb);
493   - } else {
494   - lapb->frmr_data = *frame;
495   - lapb->frmr_type = LAPB_FRMR_Z;
496   - lapb_transmit_frmr(lapb);
  470 + lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
  471 + lapb_check_need_response(lapb, frame->cr, frame->pf);
  472 + if (lapb_validate_nr(lapb, frame->nr)) {
  473 + lapb_frames_acked(lapb, frame->nr);
  474 + lapb_stop_t1timer(lapb);
  475 + lapb->n2count = 0;
  476 + lapb_requeue_frames(lapb);
  477 + } else {
  478 + lapb->frmr_data = *frame;
  479 + lapb->frmr_type = LAPB_FRMR_Z;
  480 + lapb_transmit_frmr(lapb);
497 481 #if LAPB_DEBUG > 0
498   - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
499   - lapb->dev);
  482 + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
500 483 #endif
501   - lapb_start_t1timer(lapb);
502   - lapb_stop_t2timer(lapb);
503   - lapb->state = LAPB_STATE_4;
504   - lapb->n2count = 0;
505   - }
506   - break;
  484 + lapb_start_t1timer(lapb);
  485 + lapb_stop_t2timer(lapb);
  486 + lapb->state = LAPB_STATE_4;
  487 + lapb->n2count = 0;
  488 + }
  489 + break;
507 490  
508   - case LAPB_I:
  491 + case LAPB_I:
509 492 #if LAPB_DEBUG > 1
510   - printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
511   - lapb->dev, frame->pf, frame->ns, frame->nr);
  493 + printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
  494 + lapb->dev, frame->pf, frame->ns, frame->nr);
512 495 #endif
513   - if (!lapb_validate_nr(lapb, frame->nr)) {
514   - lapb->frmr_data = *frame;
515   - lapb->frmr_type = LAPB_FRMR_Z;
516   - lapb_transmit_frmr(lapb);
  496 + if (!lapb_validate_nr(lapb, frame->nr)) {
  497 + lapb->frmr_data = *frame;
  498 + lapb->frmr_type = LAPB_FRMR_Z;
  499 + lapb_transmit_frmr(lapb);
517 500 #if LAPB_DEBUG > 0
518   - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
519   - lapb->dev);
  501 + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
520 502 #endif
521   - lapb_start_t1timer(lapb);
522   - lapb_stop_t2timer(lapb);
523   - lapb->state = LAPB_STATE_4;
524   - lapb->n2count = 0;
  503 + lapb_start_t1timer(lapb);
  504 + lapb_stop_t2timer(lapb);
  505 + lapb->state = LAPB_STATE_4;
  506 + lapb->n2count = 0;
  507 + break;
  508 + }
  509 + if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
  510 + lapb_frames_acked(lapb, frame->nr);
  511 + else
  512 + lapb_check_iframes_acked(lapb, frame->nr);
  513 +
  514 + if (frame->ns == lapb->vr) {
  515 + int cn;
  516 + cn = lapb_data_indication(lapb, skb);
  517 + queued = 1;
  518 + /*
  519 + * If upper layer has dropped the frame, we
  520 + * basically ignore any further protocol
  521 + * processing. This will cause the peer
  522 + * to re-transmit the frame later like
  523 + * a frame lost on the wire.
  524 + */
  525 + if (cn == NET_RX_DROP) {
  526 + printk(KERN_DEBUG "LAPB: rx congestion\n");
525 527 break;
526 528 }
527   - if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
528   - lapb_frames_acked(lapb, frame->nr);
529   - else
530   - lapb_check_iframes_acked(lapb, frame->nr);
531   -
532   - if (frame->ns == lapb->vr) {
533   - int cn;
534   - cn = lapb_data_indication(lapb, skb);
535   - queued = 1;
536   - /*
537   - * If upper layer has dropped the frame, we
538   - * basically ignore any further protocol
539   - * processing. This will cause the peer
540   - * to re-transmit the frame later like
541   - * a frame lost on the wire.
542   - */
543   - if (cn == NET_RX_DROP) {
544   - printk(KERN_DEBUG
545   - "LAPB: rx congestion\n");
546   - break;
  529 + lapb->vr = (lapb->vr + 1) % modulus;
  530 + lapb->condition &= ~LAPB_REJECT_CONDITION;
  531 + if (frame->pf)
  532 + lapb_enquiry_response(lapb);
  533 + else {
  534 + if (!(lapb->condition &
  535 + LAPB_ACK_PENDING_CONDITION)) {
  536 + lapb->condition |= LAPB_ACK_PENDING_CONDITION;
  537 + lapb_start_t2timer(lapb);
547 538 }
548   - lapb->vr = (lapb->vr + 1) % modulus;
549   - lapb->condition &= ~LAPB_REJECT_CONDITION;
  539 + }
  540 + } else {
  541 + if (lapb->condition & LAPB_REJECT_CONDITION) {
550 542 if (frame->pf)
551 543 lapb_enquiry_response(lapb);
552   - else {
553   - if (!(lapb->condition &
554   - LAPB_ACK_PENDING_CONDITION)) {
555   - lapb->condition |= LAPB_ACK_PENDING_CONDITION;
556   - lapb_start_t2timer(lapb);
557   - }
558   - }
559 544 } else {
560   - if (lapb->condition & LAPB_REJECT_CONDITION) {
561   - if (frame->pf)
562   - lapb_enquiry_response(lapb);
563   - } else {
564 545 #if LAPB_DEBUG > 1
565   - printk(KERN_DEBUG
566   - "lapb: (%p) S3 TX REJ(%d) R%d\n",
567   - lapb->dev, frame->pf, lapb->vr);
  546 + printk(KERN_DEBUG
  547 + "lapb: (%p) S3 TX REJ(%d) R%d\n",
  548 + lapb->dev, frame->pf, lapb->vr);
568 549 #endif
569   - lapb->condition |= LAPB_REJECT_CONDITION;
570   - lapb_send_control(lapb, LAPB_REJ,
571   - frame->pf,
572   - LAPB_RESPONSE);
573   - lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
574   - }
  550 + lapb->condition |= LAPB_REJECT_CONDITION;
  551 + lapb_send_control(lapb, LAPB_REJ, frame->pf,
  552 + LAPB_RESPONSE);
  553 + lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
575 554 }
576   - break;
  555 + }
  556 + break;
577 557  
578   - case LAPB_FRMR:
  558 + case LAPB_FRMR:
579 559 #if LAPB_DEBUG > 1
580   - printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X "
581   - "%02X %02X %02X %02X\n", lapb->dev, frame->pf,
582   - skb->data[0], skb->data[1], skb->data[2],
583   - skb->data[3], skb->data[4]);
  560 + printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X "
  561 + "%02X %02X %02X %02X\n", lapb->dev, frame->pf,
  562 + skb->data[0], skb->data[1], skb->data[2],
  563 + skb->data[3], skb->data[4]);
584 564 #endif
585   - lapb_establish_data_link(lapb);
  565 + lapb_establish_data_link(lapb);
586 566 #if LAPB_DEBUG > 0
587   - printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n",
588   - lapb->dev);
  567 + printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n", lapb->dev);
589 568 #endif
590   - lapb_requeue_frames(lapb);
591   - lapb->state = LAPB_STATE_1;
592   - break;
  569 + lapb_requeue_frames(lapb);
  570 + lapb->state = LAPB_STATE_1;
  571 + break;
593 572  
594   - case LAPB_ILLEGAL:
  573 + case LAPB_ILLEGAL:
595 574 #if LAPB_DEBUG > 1
596   - printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
597   - lapb->dev, frame->pf);
  575 + printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
  576 + lapb->dev, frame->pf);
598 577 #endif
599   - lapb->frmr_data = *frame;
600   - lapb->frmr_type = LAPB_FRMR_W;
601   - lapb_transmit_frmr(lapb);
  578 + lapb->frmr_data = *frame;
  579 + lapb->frmr_type = LAPB_FRMR_W;
  580 + lapb_transmit_frmr(lapb);
602 581 #if LAPB_DEBUG > 0
603   - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
  582 + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
604 583 #endif
605   - lapb_start_t1timer(lapb);
606   - lapb_stop_t2timer(lapb);
607   - lapb->state = LAPB_STATE_4;
608   - lapb->n2count = 0;
609   - break;
  584 + lapb_start_t1timer(lapb);
  585 + lapb_stop_t2timer(lapb);
  586 + lapb->state = LAPB_STATE_4;
  587 + lapb->n2count = 0;
  588 + break;
610 589 }
611 590  
612 591 if (!queued)
613 592  
614 593  
615 594  
616 595  
617 596  
618 597  
619 598  
620 599  
621 600  
622 601  
623 602  
624 603  
625 604  
626 605  
627 606  
... ... @@ -621,75 +600,73 @@
621 600 struct lapb_frame *frame)
622 601 {
623 602 switch (frame->type) {
624   - case LAPB_SABM:
  603 + case LAPB_SABM:
625 604 #if LAPB_DEBUG > 1
626   - printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
627   - lapb->dev, frame->pf);
  605 + printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
  606 + lapb->dev, frame->pf);
628 607 #endif
629   - if (lapb->mode & LAPB_EXTENDED) {
  608 + if (lapb->mode & LAPB_EXTENDED) {
630 609 #if LAPB_DEBUG > 1
631   - printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
632   - lapb->dev, frame->pf);
  610 + printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
  611 + lapb->dev, frame->pf);
633 612 #endif
634   - lapb_send_control(lapb, LAPB_DM, frame->pf,
635   - LAPB_RESPONSE);
636   - } else {
  613 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  614 + LAPB_RESPONSE);
  615 + } else {
637 616 #if LAPB_DEBUG > 1
638   - printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
639   - lapb->dev, frame->pf);
  617 + printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
  618 + lapb->dev, frame->pf);
640 619 #endif
641 620 #if LAPB_DEBUG > 0
642   - printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
643   - lapb->dev);
  621 + printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->dev);
644 622 #endif
645   - lapb_send_control(lapb, LAPB_UA, frame->pf,
646   - LAPB_RESPONSE);
647   - lapb_stop_t1timer(lapb);
648   - lapb_stop_t2timer(lapb);
649   - lapb->state = LAPB_STATE_3;
650   - lapb->condition = 0x00;
651   - lapb->n2count = 0;
652   - lapb->vs = 0;
653   - lapb->vr = 0;
654   - lapb->va = 0;
655   - lapb_connect_indication(lapb, LAPB_OK);
656   - }
657   - break;
  623 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  624 + LAPB_RESPONSE);
  625 + lapb_stop_t1timer(lapb);
  626 + lapb_stop_t2timer(lapb);
  627 + lapb->state = LAPB_STATE_3;
  628 + lapb->condition = 0x00;
  629 + lapb->n2count = 0;
  630 + lapb->vs = 0;
  631 + lapb->vr = 0;
  632 + lapb->va = 0;
  633 + lapb_connect_indication(lapb, LAPB_OK);
  634 + }
  635 + break;
658 636  
659   - case LAPB_SABME:
  637 + case LAPB_SABME:
660 638 #if LAPB_DEBUG > 1
661   - printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
662   - lapb->dev, frame->pf);
  639 + printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
  640 + lapb->dev, frame->pf);
663 641 #endif
664   - if (lapb->mode & LAPB_EXTENDED) {
  642 + if (lapb->mode & LAPB_EXTENDED) {
665 643 #if LAPB_DEBUG > 1
666   - printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
667   - lapb->dev, frame->pf);
  644 + printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
  645 + lapb->dev, frame->pf);
668 646 #endif
669 647 #if LAPB_DEBUG > 0
670   - printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
671   - lapb->dev);
  648 + printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->dev);
672 649 #endif
673   - lapb_send_control(lapb, LAPB_UA, frame->pf,
674   - LAPB_RESPONSE);
675   - lapb_stop_t1timer(lapb);
676   - lapb_stop_t2timer(lapb);
677   - lapb->state = LAPB_STATE_3;
678   - lapb->condition = 0x00;
679   - lapb->n2count = 0;
680   - lapb->vs = 0;
681   - lapb->vr = 0;
682   - lapb->va = 0;
683   - lapb_connect_indication(lapb, LAPB_OK);
684   - } else {
  650 + lapb_send_control(lapb, LAPB_UA, frame->pf,
  651 + LAPB_RESPONSE);
  652 + lapb_stop_t1timer(lapb);
  653 + lapb_stop_t2timer(lapb);
  654 + lapb->state = LAPB_STATE_3;
  655 + lapb->condition = 0x00;
  656 + lapb->n2count = 0;
  657 + lapb->vs = 0;
  658 + lapb->vr = 0;
  659 + lapb->va = 0;
  660 + lapb_connect_indication(lapb, LAPB_OK);
  661 + } else {
685 662 #if LAPB_DEBUG > 1
686   - printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
687   - lapb->dev, frame->pf);
  663 + printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
  664 + lapb->dev, frame->pf);
688 665 #endif
689   - lapb_send_control(lapb, LAPB_DM, frame->pf,
690   - LAPB_RESPONSE);
691   - }
692   - break;
  666 + lapb_send_control(lapb, LAPB_DM, frame->pf,
  667 + LAPB_RESPONSE);
  668 + }
  669 + break;
693 670 }
694 671  
695 672 kfree_skb(skb);