]>
Commit | Line | Data |
---|---|---|
d510fe70 GY |
1 | /* |
2 | * Blackfin Infra-red Driver | |
3 | * | |
4 | * Copyright 2006-2009 Analog Devices Inc. | |
5 | * | |
6 | * Enter bugs at http://blackfin.uclinux.org/ | |
7 | * | |
8 | * Licensed under the GPL-2 or later. | |
9 | * | |
10 | */ | |
11 | #include "bfin_sir.h" | |
12 | ||
13 | #ifdef CONFIG_SIR_BFIN_DMA | |
14 | #define DMA_SIR_RX_XCNT 10 | |
15 | #define DMA_SIR_RX_YCNT (PAGE_SIZE / DMA_SIR_RX_XCNT) | |
16 | #define DMA_SIR_RX_FLUSH_JIFS (HZ * 4 / 250) | |
17 | #endif | |
18 | ||
19 | #if ANOMALY_05000447 | |
20 | static int max_rate = 57600; | |
21 | #else | |
22 | static int max_rate = 115200; | |
23 | #endif | |
24 | ||
25 | static void turnaround_delay(unsigned long last_jif, int mtt) | |
26 | { | |
27 | long ticks; | |
28 | ||
29 | mtt = mtt < 10000 ? 10000 : mtt; | |
30 | ticks = 1 + mtt / (USEC_PER_SEC / HZ); | |
31 | schedule_timeout_uninterruptible(ticks); | |
32 | } | |
33 | ||
45ac936c | 34 | static void bfin_sir_init_ports(struct bfin_sir_port *sp, struct platform_device *pdev) |
d510fe70 GY |
35 | { |
36 | int i; | |
37 | struct resource *res; | |
38 | ||
39 | for (i = 0; i < pdev->num_resources; i++) { | |
40 | res = &pdev->resource[i]; | |
41 | switch (res->flags) { | |
42 | case IORESOURCE_MEM: | |
43 | sp->membase = (void __iomem *)res->start; | |
44 | break; | |
45 | case IORESOURCE_IRQ: | |
46 | sp->irq = res->start; | |
47 | break; | |
48 | case IORESOURCE_DMA: | |
49 | sp->rx_dma_channel = res->start; | |
50 | sp->tx_dma_channel = res->end; | |
51 | break; | |
52 | default: | |
53 | break; | |
54 | } | |
55 | } | |
56 | ||
57 | sp->clk = get_sclk(); | |
58 | #ifdef CONFIG_SIR_BFIN_DMA | |
59 | sp->tx_done = 1; | |
60 | init_timer(&(sp->rx_dma_timer)); | |
61 | #endif | |
62 | } | |
63 | ||
64 | static void bfin_sir_stop_tx(struct bfin_sir_port *port) | |
65 | { | |
66 | #ifdef CONFIG_SIR_BFIN_DMA | |
67 | disable_dma(port->tx_dma_channel); | |
68 | #endif | |
69 | ||
229de618 | 70 | while (!(UART_GET_LSR(port) & THRE)) { |
d510fe70 GY |
71 | cpu_relax(); |
72 | continue; | |
73 | } | |
74 | ||
229de618 | 75 | UART_CLEAR_IER(port, ETBEI); |
d510fe70 GY |
76 | } |
77 | ||
78 | static void bfin_sir_enable_tx(struct bfin_sir_port *port) | |
79 | { | |
229de618 | 80 | UART_SET_IER(port, ETBEI); |
d510fe70 GY |
81 | } |
82 | ||
83 | static void bfin_sir_stop_rx(struct bfin_sir_port *port) | |
84 | { | |
229de618 | 85 | UART_CLEAR_IER(port, ERBFI); |
d510fe70 GY |
86 | } |
87 | ||
88 | static void bfin_sir_enable_rx(struct bfin_sir_port *port) | |
89 | { | |
229de618 | 90 | UART_SET_IER(port, ERBFI); |
d510fe70 GY |
91 | } |
92 | ||
93 | static int bfin_sir_set_speed(struct bfin_sir_port *port, int speed) | |
94 | { | |
95 | int ret = -EINVAL; | |
96 | unsigned int quot; | |
97 | unsigned short val, lsr, lcr; | |
98 | static int utime; | |
99 | int count = 10; | |
100 | ||
101 | lcr = WLS(8); | |
102 | ||
103 | switch (speed) { | |
104 | case 9600: | |
105 | case 19200: | |
106 | case 38400: | |
107 | case 57600: | |
108 | case 115200: | |
109 | ||
eda6e6f8 GY |
110 | /* |
111 | * IRDA is not affected by anomaly 05000230, so there is no | |
112 | * need to tweak the divisor like he UART driver (which will | |
113 | * slightly speed up the baud rate on us). | |
114 | */ | |
115 | quot = (port->clk + (8 * speed)) / (16 * speed); | |
d510fe70 GY |
116 | |
117 | do { | |
118 | udelay(utime); | |
229de618 | 119 | lsr = UART_GET_LSR(port); |
d510fe70 GY |
120 | } while (!(lsr & TEMT) && count--); |
121 | ||
122 | /* The useconds for 1 bits to transmit */ | |
123 | utime = 1000000 / speed + 1; | |
124 | ||
125 | /* Clear UCEN bit to reset the UART state machine | |
126 | * and control registers | |
127 | */ | |
229de618 | 128 | val = UART_GET_GCTL(port); |
d510fe70 | 129 | val &= ~UCEN; |
229de618 | 130 | UART_PUT_GCTL(port, val); |
d510fe70 GY |
131 | |
132 | /* Set DLAB in LCR to Access THR RBR IER */ | |
229de618 | 133 | UART_SET_DLAB(port); |
d510fe70 GY |
134 | SSYNC(); |
135 | ||
229de618 MF |
136 | UART_PUT_DLL(port, quot & 0xFF); |
137 | UART_PUT_DLH(port, (quot >> 8) & 0xFF); | |
d510fe70 GY |
138 | SSYNC(); |
139 | ||
140 | /* Clear DLAB in LCR */ | |
229de618 | 141 | UART_CLEAR_DLAB(port); |
d510fe70 GY |
142 | SSYNC(); |
143 | ||
229de618 | 144 | UART_PUT_LCR(port, lcr); |
d510fe70 | 145 | |
229de618 | 146 | val = UART_GET_GCTL(port); |
d510fe70 | 147 | val |= UCEN; |
229de618 | 148 | UART_PUT_GCTL(port, val); |
d510fe70 GY |
149 | |
150 | ret = 0; | |
151 | break; | |
152 | default: | |
153 | printk(KERN_WARNING "bfin_sir: Invalid speed %d\n", speed); | |
154 | break; | |
155 | } | |
156 | ||
229de618 | 157 | val = UART_GET_GCTL(port); |
d510fe70 GY |
158 | /* If not add the 'RPOLC', we can't catch the receive interrupt. |
159 | * It's related with the HW layout and the IR transiver. | |
160 | */ | |
920d087e | 161 | val |= UMOD_IRDA | RPOLC; |
229de618 | 162 | UART_PUT_GCTL(port, val); |
d510fe70 GY |
163 | return ret; |
164 | } | |
165 | ||
166 | static int bfin_sir_is_receiving(struct net_device *dev) | |
167 | { | |
168 | struct bfin_sir_self *self = netdev_priv(dev); | |
169 | struct bfin_sir_port *port = self->sir_port; | |
170 | ||
229de618 | 171 | if (!(UART_GET_IER(port) & ERBFI)) |
d510fe70 GY |
172 | return 0; |
173 | return self->rx_buff.state != OUTSIDE_FRAME; | |
174 | } | |
175 | ||
176 | #ifdef CONFIG_SIR_BFIN_PIO | |
177 | static void bfin_sir_tx_chars(struct net_device *dev) | |
178 | { | |
179 | unsigned int chr; | |
180 | struct bfin_sir_self *self = netdev_priv(dev); | |
181 | struct bfin_sir_port *port = self->sir_port; | |
182 | ||
183 | if (self->tx_buff.len != 0) { | |
184 | chr = *(self->tx_buff.data); | |
229de618 | 185 | UART_PUT_CHAR(port, chr); |
d510fe70 GY |
186 | self->tx_buff.data++; |
187 | self->tx_buff.len--; | |
188 | } else { | |
189 | self->stats.tx_packets++; | |
190 | self->stats.tx_bytes += self->tx_buff.data - self->tx_buff.head; | |
191 | if (self->newspeed) { | |
192 | bfin_sir_set_speed(port, self->newspeed); | |
193 | self->speed = self->newspeed; | |
194 | self->newspeed = 0; | |
195 | } | |
196 | bfin_sir_stop_tx(port); | |
197 | bfin_sir_enable_rx(port); | |
198 | /* I'm hungry! */ | |
199 | netif_wake_queue(dev); | |
200 | } | |
201 | } | |
202 | ||
203 | static void bfin_sir_rx_chars(struct net_device *dev) | |
204 | { | |
205 | struct bfin_sir_self *self = netdev_priv(dev); | |
206 | struct bfin_sir_port *port = self->sir_port; | |
207 | unsigned char ch; | |
208 | ||
229de618 MF |
209 | UART_CLEAR_LSR(port); |
210 | ch = UART_GET_CHAR(port); | |
d510fe70 GY |
211 | async_unwrap_char(dev, &self->stats, &self->rx_buff, ch); |
212 | dev->last_rx = jiffies; | |
213 | } | |
214 | ||
215 | static irqreturn_t bfin_sir_rx_int(int irq, void *dev_id) | |
216 | { | |
217 | struct net_device *dev = dev_id; | |
218 | struct bfin_sir_self *self = netdev_priv(dev); | |
219 | struct bfin_sir_port *port = self->sir_port; | |
220 | ||
221 | spin_lock(&self->lock); | |
229de618 | 222 | while ((UART_GET_LSR(port) & DR)) |
d510fe70 GY |
223 | bfin_sir_rx_chars(dev); |
224 | spin_unlock(&self->lock); | |
225 | ||
226 | return IRQ_HANDLED; | |
227 | } | |
228 | ||
229 | static irqreturn_t bfin_sir_tx_int(int irq, void *dev_id) | |
230 | { | |
231 | struct net_device *dev = dev_id; | |
232 | struct bfin_sir_self *self = netdev_priv(dev); | |
233 | struct bfin_sir_port *port = self->sir_port; | |
234 | ||
235 | spin_lock(&self->lock); | |
229de618 | 236 | if (UART_GET_LSR(port) & THRE) |
d510fe70 GY |
237 | bfin_sir_tx_chars(dev); |
238 | spin_unlock(&self->lock); | |
239 | ||
240 | return IRQ_HANDLED; | |
241 | } | |
242 | #endif /* CONFIG_SIR_BFIN_PIO */ | |
243 | ||
244 | #ifdef CONFIG_SIR_BFIN_DMA | |
245 | static void bfin_sir_dma_tx_chars(struct net_device *dev) | |
246 | { | |
247 | struct bfin_sir_self *self = netdev_priv(dev); | |
248 | struct bfin_sir_port *port = self->sir_port; | |
249 | ||
250 | if (!port->tx_done) | |
251 | return; | |
252 | port->tx_done = 0; | |
253 | ||
254 | if (self->tx_buff.len == 0) { | |
255 | self->stats.tx_packets++; | |
256 | if (self->newspeed) { | |
257 | bfin_sir_set_speed(port, self->newspeed); | |
258 | self->speed = self->newspeed; | |
259 | self->newspeed = 0; | |
260 | } | |
261 | bfin_sir_enable_rx(port); | |
262 | port->tx_done = 1; | |
263 | netif_wake_queue(dev); | |
264 | return; | |
265 | } | |
266 | ||
267 | blackfin_dcache_flush_range((unsigned long)(self->tx_buff.data), | |
268 | (unsigned long)(self->tx_buff.data+self->tx_buff.len)); | |
269 | set_dma_config(port->tx_dma_channel, | |
270 | set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP, | |
271 | INTR_ON_BUF, DIMENSION_LINEAR, DATA_SIZE_8, | |
272 | DMA_SYNC_RESTART)); | |
273 | set_dma_start_addr(port->tx_dma_channel, | |
274 | (unsigned long)(self->tx_buff.data)); | |
275 | set_dma_x_count(port->tx_dma_channel, self->tx_buff.len); | |
276 | set_dma_x_modify(port->tx_dma_channel, 1); | |
277 | enable_dma(port->tx_dma_channel); | |
278 | } | |
279 | ||
280 | static irqreturn_t bfin_sir_dma_tx_int(int irq, void *dev_id) | |
281 | { | |
282 | struct net_device *dev = dev_id; | |
283 | struct bfin_sir_self *self = netdev_priv(dev); | |
284 | struct bfin_sir_port *port = self->sir_port; | |
285 | ||
286 | spin_lock(&self->lock); | |
287 | if (!(get_dma_curr_irqstat(port->tx_dma_channel) & DMA_RUN)) { | |
288 | clear_dma_irqstat(port->tx_dma_channel); | |
289 | bfin_sir_stop_tx(port); | |
290 | ||
291 | self->stats.tx_packets++; | |
292 | self->stats.tx_bytes += self->tx_buff.len; | |
293 | self->tx_buff.len = 0; | |
294 | if (self->newspeed) { | |
295 | bfin_sir_set_speed(port, self->newspeed); | |
296 | self->speed = self->newspeed; | |
297 | self->newspeed = 0; | |
298 | } | |
299 | bfin_sir_enable_rx(port); | |
300 | /* I'm hungry! */ | |
301 | netif_wake_queue(dev); | |
302 | port->tx_done = 1; | |
303 | } | |
304 | spin_unlock(&self->lock); | |
305 | ||
306 | return IRQ_HANDLED; | |
307 | } | |
308 | ||
309 | static void bfin_sir_dma_rx_chars(struct net_device *dev) | |
310 | { | |
311 | struct bfin_sir_self *self = netdev_priv(dev); | |
312 | struct bfin_sir_port *port = self->sir_port; | |
313 | int i; | |
314 | ||
229de618 | 315 | UART_CLEAR_LSR(port); |
d510fe70 GY |
316 | |
317 | for (i = port->rx_dma_buf.head; i < port->rx_dma_buf.tail; i++) | |
318 | async_unwrap_char(dev, &self->stats, &self->rx_buff, port->rx_dma_buf.buf[i]); | |
319 | } | |
320 | ||
321 | void bfin_sir_rx_dma_timeout(struct net_device *dev) | |
322 | { | |
323 | struct bfin_sir_self *self = netdev_priv(dev); | |
324 | struct bfin_sir_port *port = self->sir_port; | |
325 | int x_pos, pos; | |
326 | unsigned long flags; | |
327 | ||
328 | spin_lock_irqsave(&self->lock, flags); | |
329 | x_pos = DMA_SIR_RX_XCNT - get_dma_curr_xcount(port->rx_dma_channel); | |
330 | if (x_pos == DMA_SIR_RX_XCNT) | |
331 | x_pos = 0; | |
332 | ||
333 | pos = port->rx_dma_nrows * DMA_SIR_RX_XCNT + x_pos; | |
334 | ||
335 | if (pos > port->rx_dma_buf.tail) { | |
336 | port->rx_dma_buf.tail = pos; | |
337 | bfin_sir_dma_rx_chars(dev); | |
338 | port->rx_dma_buf.head = port->rx_dma_buf.tail; | |
339 | } | |
340 | spin_unlock_irqrestore(&self->lock, flags); | |
341 | } | |
342 | ||
343 | static irqreturn_t bfin_sir_dma_rx_int(int irq, void *dev_id) | |
344 | { | |
345 | struct net_device *dev = dev_id; | |
346 | struct bfin_sir_self *self = netdev_priv(dev); | |
347 | struct bfin_sir_port *port = self->sir_port; | |
348 | unsigned short irqstat; | |
349 | ||
350 | spin_lock(&self->lock); | |
351 | ||
352 | port->rx_dma_nrows++; | |
353 | port->rx_dma_buf.tail = DMA_SIR_RX_XCNT * port->rx_dma_nrows; | |
354 | bfin_sir_dma_rx_chars(dev); | |
355 | if (port->rx_dma_nrows >= DMA_SIR_RX_YCNT) { | |
356 | port->rx_dma_nrows = 0; | |
357 | port->rx_dma_buf.tail = 0; | |
358 | } | |
359 | port->rx_dma_buf.head = port->rx_dma_buf.tail; | |
360 | ||
361 | irqstat = get_dma_curr_irqstat(port->rx_dma_channel); | |
362 | clear_dma_irqstat(port->rx_dma_channel); | |
363 | spin_unlock(&self->lock); | |
364 | ||
365 | mod_timer(&port->rx_dma_timer, jiffies + DMA_SIR_RX_FLUSH_JIFS); | |
366 | return IRQ_HANDLED; | |
367 | } | |
368 | #endif /* CONFIG_SIR_BFIN_DMA */ | |
369 | ||
370 | static int bfin_sir_startup(struct bfin_sir_port *port, struct net_device *dev) | |
371 | { | |
372 | #ifdef CONFIG_SIR_BFIN_DMA | |
373 | dma_addr_t dma_handle; | |
374 | #endif /* CONFIG_SIR_BFIN_DMA */ | |
375 | ||
376 | if (request_dma(port->rx_dma_channel, "BFIN_UART_RX") < 0) { | |
377 | dev_warn(&dev->dev, "Unable to attach SIR RX DMA channel\n"); | |
378 | return -EBUSY; | |
379 | } | |
380 | ||
381 | if (request_dma(port->tx_dma_channel, "BFIN_UART_TX") < 0) { | |
382 | dev_warn(&dev->dev, "Unable to attach SIR TX DMA channel\n"); | |
383 | free_dma(port->rx_dma_channel); | |
384 | return -EBUSY; | |
385 | } | |
386 | ||
387 | #ifdef CONFIG_SIR_BFIN_DMA | |
388 | ||
389 | set_dma_callback(port->rx_dma_channel, bfin_sir_dma_rx_int, dev); | |
390 | set_dma_callback(port->tx_dma_channel, bfin_sir_dma_tx_int, dev); | |
391 | ||
392 | port->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA); | |
393 | port->rx_dma_buf.head = 0; | |
394 | port->rx_dma_buf.tail = 0; | |
395 | port->rx_dma_nrows = 0; | |
396 | ||
397 | set_dma_config(port->rx_dma_channel, | |
398 | set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO, | |
399 | INTR_ON_ROW, DIMENSION_2D, | |
400 | DATA_SIZE_8, DMA_SYNC_RESTART)); | |
401 | set_dma_x_count(port->rx_dma_channel, DMA_SIR_RX_XCNT); | |
402 | set_dma_x_modify(port->rx_dma_channel, 1); | |
403 | set_dma_y_count(port->rx_dma_channel, DMA_SIR_RX_YCNT); | |
404 | set_dma_y_modify(port->rx_dma_channel, 1); | |
405 | set_dma_start_addr(port->rx_dma_channel, (unsigned long)port->rx_dma_buf.buf); | |
406 | enable_dma(port->rx_dma_channel); | |
407 | ||
408 | port->rx_dma_timer.data = (unsigned long)(dev); | |
409 | port->rx_dma_timer.function = (void *)bfin_sir_rx_dma_timeout; | |
410 | ||
411 | #else | |
412 | ||
413 | if (request_irq(port->irq, bfin_sir_rx_int, IRQF_DISABLED, "BFIN_SIR_RX", dev)) { | |
414 | dev_warn(&dev->dev, "Unable to attach SIR RX interrupt\n"); | |
415 | return -EBUSY; | |
416 | } | |
417 | ||
418 | if (request_irq(port->irq+1, bfin_sir_tx_int, IRQF_DISABLED, "BFIN_SIR_TX", dev)) { | |
419 | dev_warn(&dev->dev, "Unable to attach SIR TX interrupt\n"); | |
420 | free_irq(port->irq, dev); | |
421 | return -EBUSY; | |
422 | } | |
423 | #endif | |
424 | ||
425 | return 0; | |
426 | } | |
427 | ||
428 | static void bfin_sir_shutdown(struct bfin_sir_port *port, struct net_device *dev) | |
429 | { | |
430 | unsigned short val; | |
431 | ||
432 | bfin_sir_stop_rx(port); | |
d510fe70 | 433 | |
229de618 | 434 | val = UART_GET_GCTL(port); |
920d087e | 435 | val &= ~(UCEN | UMOD_MASK | RPOLC); |
229de618 | 436 | UART_PUT_GCTL(port, val); |
d510fe70 GY |
437 | |
438 | #ifdef CONFIG_SIR_BFIN_DMA | |
439 | disable_dma(port->tx_dma_channel); | |
440 | disable_dma(port->rx_dma_channel); | |
441 | del_timer(&(port->rx_dma_timer)); | |
442 | dma_free_coherent(NULL, PAGE_SIZE, port->rx_dma_buf.buf, 0); | |
443 | #else | |
444 | free_irq(port->irq+1, dev); | |
445 | free_irq(port->irq, dev); | |
446 | #endif | |
447 | free_dma(port->tx_dma_channel); | |
448 | free_dma(port->rx_dma_channel); | |
449 | } | |
450 | ||
451 | #ifdef CONFIG_PM | |
452 | static int bfin_sir_suspend(struct platform_device *pdev, pm_message_t state) | |
453 | { | |
454 | struct bfin_sir_port *sir_port; | |
455 | struct net_device *dev; | |
456 | struct bfin_sir_self *self; | |
457 | ||
458 | sir_port = platform_get_drvdata(pdev); | |
459 | if (!sir_port) | |
460 | return 0; | |
461 | ||
462 | dev = sir_port->dev; | |
463 | self = netdev_priv(dev); | |
464 | if (self->open) { | |
465 | flush_work(&self->work); | |
466 | bfin_sir_shutdown(self->sir_port, dev); | |
467 | netif_device_detach(dev); | |
468 | } | |
469 | ||
470 | return 0; | |
471 | } | |
472 | static int bfin_sir_resume(struct platform_device *pdev) | |
473 | { | |
474 | struct bfin_sir_port *sir_port; | |
475 | struct net_device *dev; | |
476 | struct bfin_sir_self *self; | |
477 | struct bfin_sir_port *port; | |
478 | ||
479 | sir_port = platform_get_drvdata(pdev); | |
480 | if (!sir_port) | |
481 | return 0; | |
482 | ||
483 | dev = sir_port->dev; | |
484 | self = netdev_priv(dev); | |
485 | port = self->sir_port; | |
486 | if (self->open) { | |
487 | if (self->newspeed) { | |
488 | self->speed = self->newspeed; | |
489 | self->newspeed = 0; | |
490 | } | |
491 | bfin_sir_startup(port, dev); | |
492 | bfin_sir_set_speed(port, 9600); | |
493 | bfin_sir_enable_rx(port); | |
494 | netif_device_attach(dev); | |
495 | } | |
496 | return 0; | |
497 | } | |
498 | #else | |
499 | #define bfin_sir_suspend NULL | |
500 | #define bfin_sir_resume NULL | |
501 | #endif | |
502 | ||
503 | static void bfin_sir_send_work(struct work_struct *work) | |
504 | { | |
505 | struct bfin_sir_self *self = container_of(work, struct bfin_sir_self, work); | |
506 | struct net_device *dev = self->sir_port->dev; | |
507 | struct bfin_sir_port *port = self->sir_port; | |
508 | unsigned short val; | |
509 | int tx_cnt = 10; | |
510 | ||
511 | while (bfin_sir_is_receiving(dev) && --tx_cnt) | |
512 | turnaround_delay(dev->last_rx, self->mtt); | |
513 | ||
514 | bfin_sir_stop_rx(port); | |
515 | ||
516 | /* To avoid losting RX interrupt, we reset IR function before | |
517 | * sending data. We also can set the speed, which will | |
518 | * reset all the UART. | |
519 | */ | |
229de618 | 520 | val = UART_GET_GCTL(port); |
920d087e | 521 | val &= ~(UMOD_MASK | RPOLC); |
229de618 | 522 | UART_PUT_GCTL(port, val); |
d510fe70 | 523 | SSYNC(); |
920d087e | 524 | val |= UMOD_IRDA | RPOLC; |
229de618 | 525 | UART_PUT_GCTL(port, val); |
d510fe70 GY |
526 | SSYNC(); |
527 | /* bfin_sir_set_speed(port, self->speed); */ | |
528 | ||
529 | #ifdef CONFIG_SIR_BFIN_DMA | |
530 | bfin_sir_dma_tx_chars(dev); | |
531 | #endif | |
532 | bfin_sir_enable_tx(port); | |
533 | dev->trans_start = jiffies; | |
534 | } | |
535 | ||
536 | static int bfin_sir_hard_xmit(struct sk_buff *skb, struct net_device *dev) | |
537 | { | |
538 | struct bfin_sir_self *self = netdev_priv(dev); | |
539 | int speed = irda_get_next_speed(skb); | |
540 | ||
541 | netif_stop_queue(dev); | |
542 | ||
543 | self->mtt = irda_get_mtt(skb); | |
544 | ||
545 | if (speed != self->speed && speed != -1) | |
546 | self->newspeed = speed; | |
547 | ||
548 | self->tx_buff.data = self->tx_buff.head; | |
549 | if (skb->len == 0) | |
550 | self->tx_buff.len = 0; | |
551 | else | |
552 | self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, self->tx_buff.truesize); | |
553 | ||
554 | schedule_work(&self->work); | |
555 | dev_kfree_skb(skb); | |
556 | ||
557 | return 0; | |
558 | } | |
559 | ||
560 | static int bfin_sir_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd) | |
561 | { | |
562 | struct if_irda_req *rq = (struct if_irda_req *)ifreq; | |
563 | struct bfin_sir_self *self = netdev_priv(dev); | |
564 | struct bfin_sir_port *port = self->sir_port; | |
565 | int ret = 0; | |
566 | ||
567 | switch (cmd) { | |
568 | case SIOCSBANDWIDTH: | |
569 | if (capable(CAP_NET_ADMIN)) { | |
570 | if (self->open) { | |
571 | ret = bfin_sir_set_speed(port, rq->ifr_baudrate); | |
572 | bfin_sir_enable_rx(port); | |
573 | } else { | |
574 | dev_warn(&dev->dev, "SIOCSBANDWIDTH: !netif_running\n"); | |
575 | ret = 0; | |
576 | } | |
577 | } | |
578 | break; | |
579 | ||
580 | case SIOCSMEDIABUSY: | |
581 | ret = -EPERM; | |
582 | if (capable(CAP_NET_ADMIN)) { | |
583 | irda_device_set_media_busy(dev, TRUE); | |
584 | ret = 0; | |
585 | } | |
586 | break; | |
587 | ||
588 | case SIOCGRECEIVING: | |
589 | rq->ifr_receiving = bfin_sir_is_receiving(dev); | |
590 | break; | |
591 | ||
592 | default: | |
593 | ret = -EOPNOTSUPP; | |
594 | break; | |
595 | } | |
596 | ||
597 | return ret; | |
598 | } | |
599 | ||
600 | static struct net_device_stats *bfin_sir_stats(struct net_device *dev) | |
601 | { | |
602 | struct bfin_sir_self *self = netdev_priv(dev); | |
603 | ||
604 | return &self->stats; | |
605 | } | |
606 | ||
607 | static int bfin_sir_open(struct net_device *dev) | |
608 | { | |
609 | struct bfin_sir_self *self = netdev_priv(dev); | |
610 | struct bfin_sir_port *port = self->sir_port; | |
611 | int err = -ENOMEM; | |
612 | ||
613 | self->newspeed = 0; | |
614 | self->speed = 9600; | |
615 | ||
616 | spin_lock_init(&self->lock); | |
617 | ||
618 | err = bfin_sir_startup(port, dev); | |
619 | if (err) | |
620 | goto err_startup; | |
621 | ||
622 | bfin_sir_set_speed(port, 9600); | |
623 | ||
624 | self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME); | |
625 | if (!self->irlap) | |
626 | goto err_irlap; | |
627 | ||
628 | INIT_WORK(&self->work, bfin_sir_send_work); | |
629 | ||
630 | /* | |
631 | * Now enable the interrupt then start the queue | |
632 | */ | |
633 | self->open = 1; | |
634 | bfin_sir_enable_rx(port); | |
635 | ||
636 | netif_start_queue(dev); | |
637 | ||
638 | return 0; | |
639 | ||
640 | err_irlap: | |
641 | self->open = 0; | |
642 | bfin_sir_shutdown(port, dev); | |
643 | err_startup: | |
644 | return err; | |
645 | } | |
646 | ||
647 | static int bfin_sir_stop(struct net_device *dev) | |
648 | { | |
649 | struct bfin_sir_self *self = netdev_priv(dev); | |
650 | ||
651 | flush_work(&self->work); | |
652 | bfin_sir_shutdown(self->sir_port, dev); | |
653 | ||
654 | if (self->rxskb) { | |
655 | dev_kfree_skb(self->rxskb); | |
656 | self->rxskb = NULL; | |
657 | } | |
658 | ||
659 | /* Stop IrLAP */ | |
660 | if (self->irlap) { | |
661 | irlap_close(self->irlap); | |
662 | self->irlap = NULL; | |
663 | } | |
664 | ||
665 | netif_stop_queue(dev); | |
666 | self->open = 0; | |
667 | ||
668 | return 0; | |
669 | } | |
670 | ||
671 | static int bfin_sir_init_iobuf(iobuff_t *io, int size) | |
672 | { | |
673 | io->head = kmalloc(size, GFP_KERNEL); | |
674 | if (!io->head) | |
675 | return -ENOMEM; | |
676 | io->truesize = size; | |
677 | io->in_frame = FALSE; | |
678 | io->state = OUTSIDE_FRAME; | |
679 | io->data = io->head; | |
680 | return 0; | |
681 | } | |
682 | ||
d51e9b0d GY |
683 | static const struct net_device_ops bfin_sir_ndo = { |
684 | .ndo_open = bfin_sir_open, | |
685 | .ndo_stop = bfin_sir_stop, | |
686 | .ndo_start_xmit = bfin_sir_hard_xmit, | |
687 | .ndo_do_ioctl = bfin_sir_ioctl, | |
688 | .ndo_get_stats = bfin_sir_stats, | |
689 | }; | |
690 | ||
45ac936c | 691 | static int bfin_sir_probe(struct platform_device *pdev) |
d510fe70 GY |
692 | { |
693 | struct net_device *dev; | |
694 | struct bfin_sir_self *self; | |
695 | unsigned int baudrate_mask; | |
696 | struct bfin_sir_port *sir_port; | |
697 | int err; | |
698 | ||
699 | if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \ | |
700 | per[pdev->id][3] == pdev->id) { | |
701 | err = peripheral_request_list(per[pdev->id], DRIVER_NAME); | |
702 | if (err) | |
703 | return err; | |
704 | } else { | |
705 | dev_err(&pdev->dev, "Invalid pdev id, please check board file\n"); | |
706 | return -ENODEV; | |
707 | } | |
708 | ||
709 | err = -ENOMEM; | |
710 | sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL); | |
711 | if (!sir_port) | |
712 | goto err_mem_0; | |
713 | ||
714 | bfin_sir_init_ports(sir_port, pdev); | |
715 | ||
716 | dev = alloc_irdadev(sizeof(*self)); | |
717 | if (!dev) | |
718 | goto err_mem_1; | |
719 | ||
720 | self = netdev_priv(dev); | |
721 | self->dev = &pdev->dev; | |
722 | self->sir_port = sir_port; | |
723 | sir_port->dev = dev; | |
724 | ||
725 | err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU); | |
726 | if (err) | |
727 | goto err_mem_2; | |
728 | err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME); | |
729 | if (err) | |
730 | goto err_mem_3; | |
731 | ||
d51e9b0d GY |
732 | dev->netdev_ops = &bfin_sir_ndo; |
733 | dev->irq = sir_port->irq; | |
d510fe70 GY |
734 | |
735 | irda_init_max_qos_capabilies(&self->qos); | |
736 | ||
737 | baudrate_mask = IR_9600; | |
738 | ||
739 | switch (max_rate) { | |
740 | case 115200: | |
741 | baudrate_mask |= IR_115200; | |
742 | case 57600: | |
743 | baudrate_mask |= IR_57600; | |
744 | case 38400: | |
745 | baudrate_mask |= IR_38400; | |
746 | case 19200: | |
747 | baudrate_mask |= IR_19200; | |
748 | case 9600: | |
749 | break; | |
750 | default: | |
751 | dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n"); | |
752 | } | |
753 | ||
754 | self->qos.baud_rate.bits &= baudrate_mask; | |
755 | ||
756 | self->qos.min_turn_time.bits = 1; /* 10 ms or more */ | |
757 | ||
758 | irda_qos_bits_to_value(&self->qos); | |
759 | ||
760 | err = register_netdev(dev); | |
761 | ||
762 | if (err) { | |
763 | kfree(self->tx_buff.head); | |
764 | err_mem_3: | |
765 | kfree(self->rx_buff.head); | |
766 | err_mem_2: | |
767 | free_netdev(dev); | |
768 | err_mem_1: | |
769 | kfree(sir_port); | |
770 | err_mem_0: | |
771 | peripheral_free_list(per[pdev->id]); | |
772 | } else | |
773 | platform_set_drvdata(pdev, sir_port); | |
774 | ||
775 | return err; | |
776 | } | |
777 | ||
45ac936c | 778 | static int bfin_sir_remove(struct platform_device *pdev) |
d510fe70 GY |
779 | { |
780 | struct bfin_sir_port *sir_port; | |
781 | struct net_device *dev = NULL; | |
782 | struct bfin_sir_self *self; | |
783 | ||
784 | sir_port = platform_get_drvdata(pdev); | |
785 | if (!sir_port) | |
786 | return 0; | |
787 | dev = sir_port->dev; | |
788 | self = netdev_priv(dev); | |
789 | unregister_netdev(dev); | |
790 | kfree(self->tx_buff.head); | |
791 | kfree(self->rx_buff.head); | |
792 | free_netdev(dev); | |
793 | kfree(sir_port); | |
794 | platform_set_drvdata(pdev, NULL); | |
795 | ||
796 | return 0; | |
797 | } | |
798 | ||
799 | static struct platform_driver bfin_ir_driver = { | |
800 | .probe = bfin_sir_probe, | |
45ac936c | 801 | .remove = bfin_sir_remove, |
d510fe70 GY |
802 | .suspend = bfin_sir_suspend, |
803 | .resume = bfin_sir_resume, | |
804 | .driver = { | |
805 | .name = DRIVER_NAME, | |
806 | }, | |
807 | }; | |
808 | ||
8b7ff200 | 809 | module_platform_driver(bfin_ir_driver); |
d510fe70 GY |
810 | |
811 | module_param(max_rate, int, 0); | |
812 | MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)"); | |
813 | ||
814 | MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>"); | |
815 | MODULE_DESCRIPTION("Blackfin IrDA driver"); | |
816 | MODULE_LICENSE("GPL"); |