2 * Freescale QUICC Engine USB Host Controller Driver
4 * Copyright (c) Freescale Semicondutor, Inc. 2006.
5 * Shlomi Gridish <gridish@freescale.com>
6 * Jerry Huang <Chang-Ming.Huang@freescale.com>
7 * Copyright (c) Logic Product Development, Inc. 2007
8 * Peter Barada <peterb@logicpd.com>
9 * Copyright (c) MontaVista Software, Inc. 2008.
10 * Anton Vorontsov <avorontsov@ru.mvista.com>
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/spinlock.h>
21 #include <linux/kernel.h>
22 #include <linux/delay.h>
23 #include <linux/errno.h>
24 #include <linux/list.h>
25 #include <linux/interrupt.h>
27 #include <linux/usb.h>
28 #include <linux/usb/hcd.h>
29 #include <linux/of_platform.h>
30 #include <linux/of_gpio.h>
31 #include <linux/slab.h>
33 #include <asm/fsl_gtm.h>
36 void fhci_start_sof_timer(struct fhci_hcd
*fhci
)
38 fhci_dbg(fhci
, "-> %s\n", __func__
);
41 out_be16(&fhci
->pram
->frame_num
, 0);
43 out_be16(&fhci
->regs
->usb_sof_tmr
, 0);
44 setbits8(&fhci
->regs
->usb_mod
, USB_MODE_SFTE
);
46 fhci_dbg(fhci
, "<- %s\n", __func__
);
49 void fhci_stop_sof_timer(struct fhci_hcd
*fhci
)
51 fhci_dbg(fhci
, "-> %s\n", __func__
);
53 clrbits8(&fhci
->regs
->usb_mod
, USB_MODE_SFTE
);
54 gtm_stop_timer16(fhci
->timer
);
56 fhci_dbg(fhci
, "<- %s\n", __func__
);
59 u16
fhci_get_sof_timer_count(struct fhci_usb
*usb
)
61 return be16_to_cpu(in_be16(&usb
->fhci
->regs
->usb_sof_tmr
) / 12);
64 /* initialize the endpoint zero */
65 static u32
endpoint_zero_init(struct fhci_usb
*usb
,
66 enum fhci_mem_alloc data_mem
,
71 rc
= fhci_create_ep(usb
, data_mem
, ring_len
);
75 /* inilialize endpoint registers */
76 fhci_init_ep_registers(usb
, usb
->ep0
, data_mem
);
81 /* enable the USB interrupts */
82 void fhci_usb_enable_interrupt(struct fhci_usb
*usb
)
84 struct fhci_hcd
*fhci
= usb
->fhci
;
86 if (usb
->intr_nesting_cnt
== 1) {
87 /* initialize the USB interrupt */
88 enable_irq(fhci_to_hcd(fhci
)->irq
);
90 /* initialize the event register and mask register */
91 out_be16(&usb
->fhci
->regs
->usb_event
, 0xffff);
92 out_be16(&usb
->fhci
->regs
->usb_mask
, usb
->saved_msk
);
94 /* enable the timer interrupts */
95 enable_irq(fhci
->timer
->irq
);
96 } else if (usb
->intr_nesting_cnt
> 1)
97 fhci_info(fhci
, "unbalanced USB interrupts nesting\n");
98 usb
->intr_nesting_cnt
--;
101 /* disable the usb interrupt */
102 void fhci_usb_disable_interrupt(struct fhci_usb
*usb
)
104 struct fhci_hcd
*fhci
= usb
->fhci
;
106 if (usb
->intr_nesting_cnt
== 0) {
107 /* disable the timer interrupt */
108 disable_irq_nosync(fhci
->timer
->irq
);
110 /* disable the usb interrupt */
111 disable_irq_nosync(fhci_to_hcd(fhci
)->irq
);
112 out_be16(&usb
->fhci
->regs
->usb_mask
, 0);
114 usb
->intr_nesting_cnt
++;
117 /* enable the USB controller */
118 static u32
fhci_usb_enable(struct fhci_hcd
*fhci
)
120 struct fhci_usb
*usb
= fhci
->usb_lld
;
122 out_be16(&usb
->fhci
->regs
->usb_event
, 0xffff);
123 out_be16(&usb
->fhci
->regs
->usb_mask
, usb
->saved_msk
);
124 setbits8(&usb
->fhci
->regs
->usb_mod
, USB_MODE_EN
);
131 /* disable the USB controller */
132 static u32
fhci_usb_disable(struct fhci_hcd
*fhci
)
134 struct fhci_usb
*usb
= fhci
->usb_lld
;
136 fhci_usb_disable_interrupt(usb
);
137 fhci_port_disable(fhci
);
139 /* disable the usb controller */
140 if (usb
->port_status
== FHCI_PORT_FULL
||
141 usb
->port_status
== FHCI_PORT_LOW
)
142 fhci_device_disconnected_interrupt(fhci
);
144 clrbits8(&usb
->fhci
->regs
->usb_mod
, USB_MODE_EN
);
149 /* check the bus state by polling the QE bit on the IO ports */
150 int fhci_ioports_check_bus_state(struct fhci_hcd
*fhci
)
154 /* check USBOE,if transmitting,exit */
155 if (!gpio_get_value(fhci
->gpios
[GPIO_USBOE
]))
159 if (gpio_get_value(fhci
->gpios
[GPIO_USBRP
]))
163 if (gpio_get_value(fhci
->gpios
[GPIO_USBRN
]))
169 static void fhci_mem_free(struct fhci_hcd
*fhci
)
176 list_for_each_entry_safe(ed
, next_ed
, &fhci
->empty_eds
, node
) {
181 list_for_each_entry_safe(td
, next_td
, &fhci
->empty_tds
, node
) {
186 kfree(fhci
->vroot_hub
);
187 fhci
->vroot_hub
= NULL
;
189 kfree(fhci
->hc_list
);
190 fhci
->hc_list
= NULL
;
193 static int fhci_mem_init(struct fhci_hcd
*fhci
)
197 fhci
->hc_list
= kzalloc(sizeof(*fhci
->hc_list
), GFP_KERNEL
);
201 INIT_LIST_HEAD(&fhci
->hc_list
->ctrl_list
);
202 INIT_LIST_HEAD(&fhci
->hc_list
->bulk_list
);
203 INIT_LIST_HEAD(&fhci
->hc_list
->iso_list
);
204 INIT_LIST_HEAD(&fhci
->hc_list
->intr_list
);
205 INIT_LIST_HEAD(&fhci
->hc_list
->done_list
);
207 fhci
->vroot_hub
= kzalloc(sizeof(*fhci
->vroot_hub
), GFP_KERNEL
);
208 if (!fhci
->vroot_hub
)
211 INIT_LIST_HEAD(&fhci
->empty_eds
);
212 INIT_LIST_HEAD(&fhci
->empty_tds
);
214 /* initialize work queue to handle done list */
215 fhci_tasklet
.data
= (unsigned long)fhci
;
216 fhci
->process_done_task
= &fhci_tasklet
;
218 for (i
= 0; i
< MAX_TDS
; i
++) {
221 td
= kmalloc(sizeof(*td
), GFP_KERNEL
);
224 fhci_recycle_empty_td(fhci
, td
);
226 for (i
= 0; i
< MAX_EDS
; i
++) {
229 ed
= kmalloc(sizeof(*ed
), GFP_KERNEL
);
232 fhci_recycle_empty_ed(fhci
, ed
);
235 fhci
->active_urbs
= 0;
242 /* destroy the fhci_usb structure */
243 static void fhci_usb_free(void *lld
)
245 struct fhci_usb
*usb
= lld
;
246 struct fhci_hcd
*fhci
;
250 fhci_config_transceiver(fhci
, FHCI_PORT_POWER_OFF
);
252 kfree(usb
->actual_frame
);
257 /* initialize the USB */
258 static int fhci_usb_init(struct fhci_hcd
*fhci
)
260 struct fhci_usb
*usb
= fhci
->usb_lld
;
262 memset_io(usb
->fhci
->pram
, 0, FHCI_PRAM_SIZE
);
264 usb
->port_status
= FHCI_PORT_DISABLED
;
265 usb
->max_frame_usage
= FRAME_TIME_USAGE
;
266 usb
->sw_transaction_time
= SW_FIX_TIME_BETWEEN_TRANSACTION
;
268 usb
->actual_frame
= kzalloc(sizeof(*usb
->actual_frame
), GFP_KERNEL
);
269 if (!usb
->actual_frame
) {
274 INIT_LIST_HEAD(&usb
->actual_frame
->tds_list
);
276 /* initializing registers on chip, clear frame number */
277 out_be16(&fhci
->pram
->frame_num
, 0);
280 out_be32(&fhci
->pram
->rx_state
, 0);
282 /* set mask register */
283 usb
->saved_msk
= (USB_E_TXB_MASK
|
286 USB_E_RESET_MASK
| USB_E_SFT_MASK
| USB_E_MSF_MASK
);
288 out_8(&usb
->fhci
->regs
->usb_mod
, USB_MODE_HOST
| USB_MODE_EN
);
290 /* clearing the mask register */
291 out_be16(&usb
->fhci
->regs
->usb_mask
, 0);
293 /* initialing the event register */
294 out_be16(&usb
->fhci
->regs
->usb_event
, 0xffff);
296 if (endpoint_zero_init(usb
, DEFAULT_DATA_MEM
, DEFAULT_RING_LEN
) != 0) {
304 /* initialize the fhci_usb struct and the corresponding data staruct */
305 static struct fhci_usb
*fhci_create_lld(struct fhci_hcd
*fhci
)
307 struct fhci_usb
*usb
;
309 /* allocate memory for SCC data structure */
310 usb
= kzalloc(sizeof(*usb
), GFP_KERNEL
);
312 fhci_err(fhci
, "no memory for SCC data struct\n");
317 usb
->hc_list
= fhci
->hc_list
;
318 usb
->vroot_hub
= fhci
->vroot_hub
;
320 usb
->transfer_confirm
= fhci_transfer_confirm_callback
;
325 static int fhci_start(struct usb_hcd
*hcd
)
328 struct fhci_hcd
*fhci
= hcd_to_fhci(hcd
);
330 ret
= fhci_mem_init(fhci
);
332 fhci_err(fhci
, "failed to allocate memory\n");
336 fhci
->usb_lld
= fhci_create_lld(fhci
);
337 if (!fhci
->usb_lld
) {
338 fhci_err(fhci
, "low level driver config failed\n");
343 ret
= fhci_usb_init(fhci
);
345 fhci_err(fhci
, "low level driver initialize failed\n");
349 spin_lock_init(&fhci
->lock
);
351 /* connect the virtual root hub */
352 fhci
->vroot_hub
->dev_num
= 1; /* this field may be needed to fix */
353 fhci
->vroot_hub
->hub
.wHubStatus
= 0;
354 fhci
->vroot_hub
->hub
.wHubChange
= 0;
355 fhci
->vroot_hub
->port
.wPortStatus
= 0;
356 fhci
->vroot_hub
->port
.wPortChange
= 0;
358 hcd
->state
= HC_STATE_RUNNING
;
361 * From here on, khubd concurrently accesses the root
362 * hub; drivers will be talking to enumerated devices.
363 * (On restart paths, khubd already knows about the root
364 * hub and could find work as soon as we wrote FLAG_CF.)
366 * Before this point the HC was idle/ready. After, khubd
367 * and device drivers may start it running.
369 fhci_usb_enable(fhci
);
376 static void fhci_stop(struct usb_hcd
*hcd
)
378 struct fhci_hcd
*fhci
= hcd_to_fhci(hcd
);
380 fhci_usb_disable_interrupt(fhci
->usb_lld
);
381 fhci_usb_disable(fhci
);
383 fhci_usb_free(fhci
->usb_lld
);
384 fhci
->usb_lld
= NULL
;
388 static int fhci_urb_enqueue(struct usb_hcd
*hcd
, struct urb
*urb
,
391 struct fhci_hcd
*fhci
= hcd_to_fhci(hcd
);
392 u32 pipe
= urb
->pipe
;
396 struct urb_priv
*urb_priv
;
399 switch (usb_pipetype(pipe
)) {
401 /* 1 td fro setup,1 for ack */
404 /* one td for every 4096 bytes(can be up to 8k) */
405 size
+= urb
->transfer_buffer_length
/ 4096;
406 /* ...add for any remaining bytes... */
407 if ((urb
->transfer_buffer_length
% 4096) != 0)
409 /* ..and maybe a zero length packet to wrap it up */
412 else if ((urb
->transfer_flags
& URB_ZERO_PACKET
) != 0
413 && (urb
->transfer_buffer_length
414 % usb_maxpacket(urb
->dev
, pipe
,
415 usb_pipeout(pipe
))) != 0)
418 case PIPE_ISOCHRONOUS
:
419 size
= urb
->number_of_packets
;
422 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
423 urb
->iso_frame_desc
[i
].actual_length
= 0;
424 urb
->iso_frame_desc
[i
].status
= (u32
) (-EXDEV
);
431 /* allocate the private part of the URB */
432 urb_priv
= kzalloc(sizeof(*urb_priv
), mem_flags
);
436 /* allocate the private part of the URB */
437 urb_priv
->tds
= kcalloc(size
, sizeof(*urb_priv
->tds
), mem_flags
);
438 if (!urb_priv
->tds
) {
443 spin_lock_irqsave(&fhci
->lock
, flags
);
445 ret
= usb_hcd_link_urb_to_ep(hcd
, urb
);
449 /* fill the private part of the URB */
450 urb_priv
->num_of_tds
= size
;
452 urb
->status
= -EINPROGRESS
;
453 urb
->actual_length
= 0;
454 urb
->error_count
= 0;
455 urb
->hcpriv
= urb_priv
;
457 fhci_queue_urb(fhci
, urb
);
460 kfree(urb_priv
->tds
);
463 spin_unlock_irqrestore(&fhci
->lock
, flags
);
467 /* dequeue FHCI URB */
468 static int fhci_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
, int status
)
470 struct fhci_hcd
*fhci
= hcd_to_fhci(hcd
);
471 struct fhci_usb
*usb
= fhci
->usb_lld
;
475 if (!urb
|| !urb
->dev
|| !urb
->dev
->bus
)
478 spin_lock_irqsave(&fhci
->lock
, flags
);
480 ret
= usb_hcd_check_unlink_urb(hcd
, urb
, status
);
484 if (usb
->port_status
!= FHCI_PORT_DISABLED
) {
485 struct urb_priv
*urb_priv
;
488 * flag the urb's data for deletion in some upcoming
489 * SF interrupt's delete list processing
491 urb_priv
= urb
->hcpriv
;
493 if (!urb_priv
|| (urb_priv
->state
== URB_DEL
))
496 urb_priv
->state
= URB_DEL
;
498 /* already pending? */
499 urb_priv
->ed
->state
= FHCI_ED_URB_DEL
;
501 fhci_urb_complete_free(fhci
, urb
);
505 spin_unlock_irqrestore(&fhci
->lock
, flags
);
510 static void fhci_endpoint_disable(struct usb_hcd
*hcd
,
511 struct usb_host_endpoint
*ep
)
513 struct fhci_hcd
*fhci
;
517 fhci
= hcd_to_fhci(hcd
);
518 spin_lock_irqsave(&fhci
->lock
, flags
);
521 while (ed
->td_head
!= NULL
) {
522 struct td
*td
= fhci_remove_td_from_ed(ed
);
523 fhci_urb_complete_free(fhci
, td
->urb
);
525 fhci_recycle_empty_ed(fhci
, ed
);
528 spin_unlock_irqrestore(&fhci
->lock
, flags
);
531 static int fhci_get_frame_number(struct usb_hcd
*hcd
)
533 struct fhci_hcd
*fhci
= hcd_to_fhci(hcd
);
535 return get_frame_num(fhci
);
538 static const struct hc_driver fhci_driver
= {
539 .description
= "fsl,usb-fhci",
540 .product_desc
= "FHCI HOST Controller",
541 .hcd_priv_size
= sizeof(struct fhci_hcd
),
543 /* generic hardware linkage */
545 .flags
= HCD_USB11
| HCD_MEMORY
,
547 /* basic lifecycle operation */
551 /* managing i/o requests and associated device resources */
552 .urb_enqueue
= fhci_urb_enqueue
,
553 .urb_dequeue
= fhci_urb_dequeue
,
554 .endpoint_disable
= fhci_endpoint_disable
,
556 /* scheduling support */
557 .get_frame_number
= fhci_get_frame_number
,
559 /* root hub support */
560 .hub_status_data
= fhci_hub_status_data
,
561 .hub_control
= fhci_hub_control
,
564 static int __devinit
of_fhci_probe(struct platform_device
*ofdev
)
566 struct device
*dev
= &ofdev
->dev
;
567 struct device_node
*node
= dev
->of_node
;
569 struct fhci_hcd
*fhci
;
570 struct resource usb_regs
;
571 unsigned long pram_addr
;
572 unsigned int usb_irq
;
583 sprop
= of_get_property(node
, "mode", NULL
);
584 if (sprop
&& strcmp(sprop
, "host"))
587 hcd
= usb_create_hcd(&fhci_driver
, dev
, dev_name(dev
));
589 dev_err(dev
, "could not create hcd\n");
593 fhci
= hcd_to_fhci(hcd
);
594 hcd
->self
.controller
= dev
;
595 dev_set_drvdata(dev
, hcd
);
597 iprop
= of_get_property(node
, "hub-power-budget", &size
);
598 if (iprop
&& size
== sizeof(*iprop
))
599 hcd
->power_budget
= *iprop
;
601 /* FHCI registers. */
602 ret
= of_address_to_resource(node
, 0, &usb_regs
);
604 dev_err(dev
, "could not get regs\n");
608 hcd
->regs
= ioremap(usb_regs
.start
, resource_size(&usb_regs
));
610 dev_err(dev
, "could not ioremap regs\n");
614 fhci
->regs
= hcd
->regs
;
617 iprop
= of_get_property(node
, "reg", &size
);
618 if (!iprop
|| size
< sizeof(*iprop
) * 4) {
619 dev_err(dev
, "can't get pram offset\n");
624 pram_addr
= cpm_muram_alloc(FHCI_PRAM_SIZE
, 64);
625 if (IS_ERR_VALUE(pram_addr
)) {
626 dev_err(dev
, "failed to allocate usb pram\n");
631 qe_issue_cmd(QE_ASSIGN_PAGE_TO_DEVICE
, QE_CR_SUBBLOCK_USB
,
632 QE_CR_PROTOCOL_UNSPECIFIED
, pram_addr
);
633 fhci
->pram
= cpm_muram_addr(pram_addr
);
636 for (i
= 0; i
< NUM_GPIOS
; i
++) {
638 enum of_gpio_flags flags
;
640 gpio
= of_get_gpio_flags(node
, i
, &flags
);
641 fhci
->gpios
[i
] = gpio
;
642 fhci
->alow_gpios
[i
] = flags
& OF_GPIO_ACTIVE_LOW
;
644 if (!gpio_is_valid(gpio
)) {
645 if (i
< GPIO_SPEED
) {
646 dev_err(dev
, "incorrect GPIO%d: %d\n",
650 dev_info(dev
, "assuming board doesn't have "
651 "%s gpio\n", i
== GPIO_SPEED
?
657 ret
= gpio_request(gpio
, dev_name(dev
));
659 dev_err(dev
, "failed to request gpio %d", i
);
663 if (i
>= GPIO_SPEED
) {
664 ret
= gpio_direction_output(gpio
, 0);
666 dev_err(dev
, "failed to set gpio %d as "
674 for (j
= 0; j
< NUM_PINS
; j
++) {
675 fhci
->pins
[j
] = qe_pin_request(node
, j
);
676 if (IS_ERR(fhci
->pins
[j
])) {
677 ret
= PTR_ERR(fhci
->pins
[j
]);
678 dev_err(dev
, "can't get pin %d: %d\n", j
, ret
);
683 /* Frame limit timer and its interrupt. */
684 fhci
->timer
= gtm_get_timer16();
685 if (IS_ERR(fhci
->timer
)) {
686 ret
= PTR_ERR(fhci
->timer
);
687 dev_err(dev
, "failed to request qe timer: %i", ret
);
691 ret
= request_irq(fhci
->timer
->irq
, fhci_frame_limit_timer_irq
,
692 0, "qe timer (usb)", hcd
);
694 dev_err(dev
, "failed to request timer irq");
698 /* USB Host interrupt. */
699 usb_irq
= irq_of_parse_and_map(node
, 0);
700 if (usb_irq
== NO_IRQ
) {
701 dev_err(dev
, "could not get usb irq\n");
707 sprop
= of_get_property(node
, "fsl,fullspeed-clock", NULL
);
709 fhci
->fullspeed_clk
= qe_clock_source(sprop
);
710 if (fhci
->fullspeed_clk
== QE_CLK_DUMMY
) {
711 dev_err(dev
, "wrong fullspeed-clock\n");
717 sprop
= of_get_property(node
, "fsl,lowspeed-clock", NULL
);
719 fhci
->lowspeed_clk
= qe_clock_source(sprop
);
720 if (fhci
->lowspeed_clk
== QE_CLK_DUMMY
) {
721 dev_err(dev
, "wrong lowspeed-clock\n");
727 if (fhci
->fullspeed_clk
== QE_CLK_NONE
&&
728 fhci
->lowspeed_clk
== QE_CLK_NONE
) {
729 dev_err(dev
, "no clocks specified\n");
734 dev_info(dev
, "at 0x%p, irq %d\n", hcd
->regs
, usb_irq
);
736 fhci_config_transceiver(fhci
, FHCI_PORT_POWER_OFF
);
738 /* Start with full-speed, if possible. */
739 if (fhci
->fullspeed_clk
!= QE_CLK_NONE
) {
740 fhci_config_transceiver(fhci
, FHCI_PORT_FULL
);
741 qe_usb_clock_set(fhci
->fullspeed_clk
, USB_CLOCK
);
743 fhci_config_transceiver(fhci
, FHCI_PORT_LOW
);
744 qe_usb_clock_set(fhci
->lowspeed_clk
, USB_CLOCK
>> 3);
747 /* Clear and disable any pending interrupts. */
748 out_be16(&fhci
->regs
->usb_event
, 0xffff);
749 out_be16(&fhci
->regs
->usb_mask
, 0);
751 ret
= usb_add_hcd(hcd
, usb_irq
, 0);
755 fhci_dfs_create(fhci
);
761 irq_dispose_mapping(usb_irq
);
763 free_irq(fhci
->timer
->irq
, hcd
);
765 gtm_put_timer16(fhci
->timer
);
769 qe_pin_free(fhci
->pins
[j
]);
772 if (gpio_is_valid(fhci
->gpios
[i
]))
773 gpio_free(fhci
->gpios
[i
]);
775 cpm_muram_free(pram_addr
);
783 static int __devexit
fhci_remove(struct device
*dev
)
785 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
786 struct fhci_hcd
*fhci
= hcd_to_fhci(hcd
);
791 free_irq(fhci
->timer
->irq
, hcd
);
792 gtm_put_timer16(fhci
->timer
);
793 cpm_muram_free(cpm_muram_offset(fhci
->pram
));
794 for (i
= 0; i
< NUM_GPIOS
; i
++) {
795 if (!gpio_is_valid(fhci
->gpios
[i
]))
797 gpio_free(fhci
->gpios
[i
]);
799 for (j
= 0; j
< NUM_PINS
; j
++)
800 qe_pin_free(fhci
->pins
[j
]);
801 fhci_dfs_destroy(fhci
);
806 static int __devexit
of_fhci_remove(struct platform_device
*ofdev
)
808 return fhci_remove(&ofdev
->dev
);
811 static const struct of_device_id of_fhci_match
[] = {
812 { .compatible
= "fsl,mpc8323-qe-usb", },
815 MODULE_DEVICE_TABLE(of
, of_fhci_match
);
817 static struct platform_driver of_fhci_driver
= {
819 .name
= "fsl,usb-fhci",
820 .owner
= THIS_MODULE
,
821 .of_match_table
= of_fhci_match
,
823 .probe
= of_fhci_probe
,
824 .remove
= __devexit_p(of_fhci_remove
),
827 module_platform_driver(of_fhci_driver
);
829 MODULE_DESCRIPTION("USB Freescale Host Controller Interface Driver");
830 MODULE_AUTHOR("Shlomi Gridish <gridish@freescale.com>, "
831 "Jerry Huang <Chang-Ming.Huang@freescale.com>, "
832 "Anton Vorontsov <avorontsov@ru.mvista.com>");
833 MODULE_LICENSE("GPL");