medfield 平台 串口 console 驱动

xxha000721

位于 /drivers/serial/mfd.c 中

1. 初始化：

1. static int __init hsu_pci_init(void)
   
2. {
   
3.     int ret;
   
4. 
   
5.     hsu_global_init();                              //初始化
   
6. 
   
7.     ret = uart_register_driver(&serial_hsu_reg);   //注册UART 驱动
   
8.     if (ret)
   
9.         return ret;
   
10. 
    
11.     return pci_register_driver(&hsu_pci_driver);   //注册pci驱动
    
12. }
    
13. 
    
14. static void __exit hsu_pci_exit(void)
    
15. {
    
16.     pci_unregister_driver(&hsu_pci_driver);
    
17.     uart_unregister_driver(&serial_hsu_reg);
    
18. 
    
19.     hsu_debugfs_remove(phsu);
    
20. 
    
21.     kfree(phsu);
    
22. }
    
23. 
    
24. module_init(hsu_pci_init);
    
25. module_exit(hsu_pci_exit);
    
26. 
    
27. MODULE_LICENSE("GPL v2");
    
28. MODULE_ALIAS("platform:medfield-hsu");

 2. hsu_global_init()， 初始化3个UART 串口。

1. static void hsu_global_init(void)
   
2. {
   
3.     struct hsu_port *hsu;
   
4.     struct uart_hsu_port *uport;
   
5.     struct hsu_dma_chan *dchan;
   
6.     int i, ret;
   
7. 
   
8.     hsu = kzalloc(sizeof(struct hsu_port), GFP_KERNEL);
   
9.     if (!hsu)
   
10.         return;
    
11. 
    
12.     /* Get basic io resource and map it */
    
13.     hsu->paddr = 0xffa28000;
    
14.     hsu->iolen = 0x1000;
    
15. 
    
16.     if (!(request_mem_region(hsu->paddr, hsu->iolen, "HSU global")))
    
17.         pr_warning("HSU: error in request mem region\n");
    
18. 
    
19.     hsu->reg = ioremap_nocache((unsigned long)hsu->paddr, hsu->iolen);
    
20.     if (!hsu->reg) {
    
21.         pr_err("HSU: error in ioremap\n");
    
22.         ret = -ENOMEM;
    
23.         goto err_free_region;
    
24.     }
    
25. 
    
26.     /* Initialise the 3 UART ports */
    
27.     uport = hsu->port;
    
28.     for (i = 0; i < 3; i++) {
    
29.         uport->port.type = PORT_MFD;
    
30.         uport->port.iotype = UPIO_MEM;
    
31.         uport->port.mapbase = (resource_size_t)hsu->paddr
    
32.                     + HSU_PORT_REG_OFFSET
    
33.                     + i * HSU_PORT_REG_LENGTH;
    
34.         uport->port.membase = hsu->reg + HSU_PORT_REG_OFFSET
    
35.                     + i * HSU_PORT_REG_LENGTH;
    
36. 
    
37.         sprintf(uport->name, "hsu_port%d", i);
    
38.         uport->port.fifosize = 64;
    
39.         uport->port.ops = &serial_hsu_pops;
    
40.         uport->port.line = i;
    
41.         uport->port.flags = UPF_IOREMAP;
    
42.         /* set the scalable maxim support rate to 2746800 bps */
    
43.         uport->port.uartclk = 115200 * 24 * 16;
    
44. 
    
45.         uport->running = 0;
    
46.         uport->txc = &hsu->chans[i * 2];
    
47.         uport->rxc = &hsu->chans[i * 2 + 1];
    
48. 
    
49.         serial_hsu_ports[i] = uport;
    
50.         uport->index = i;
    
51.         uport++;
    
52.    }
    
53. 
    
54.     /* Initialise 6 dma channels */
    
55.     dchan = hsu->chans;
    
56.     for (i = 0; i < 6; i++) {
    
57.         dchan->id = i;
    
58.         dchan->dirt = (i & 0x1) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
    
59.         dchan->uport = &hsu->port[i/2];
    
60.         dchan->reg = hsu->reg + HSU_DMA_CHANS_REG_OFFSET +
    
61.                 i * HSU_DMA_CHANS_REG_LENGTH;
    
62. 
    
63.         /* Work around for RX */
    
64.         if (dmarx_need_timer() && dchan->dirt == DMA_FROM_DEVICE) {
    
65.             init_timer(&dchan->rx_timer);
    
66.             dchan->rx_timer.function = hsu_dma_rx_timeout;
    
67.             dchan->rx_timer.data = (unsigned long)dchan;
    
68.         }
    
69.         dchan++;
    
70.     }
    
71. 
    
72.     phsu = hsu;
    
73.     hsu_debugfs_init(hsu);
    
74.     return;
    
75. 
    
76. err_free_region:
    
77.     release_mem_region(hsu->paddr, hsu->iolen);
    
78.     kfree(hsu);
    
79.     return;
    
80. }

3.  串口信息配置：

1. static struct uart_driver serial_hsu_reg = {
   
2.     .owner = THIS_MODULE,
   
3.     .driver_name = "MFD serial",
   
4.     .dev_name = "ttyMFD",
   
5.     .major = TTY_MAJOR,
   
6.     .minor = 128,
   
7.     .nr = 3,
   
8. };

4. pci 驱动信息：

1. static struct pci_driver hsu_pci_driver = {
   
2.     .name =        "HSU serial",
   
3.     .id_table =    pci_ids,
   
4.     .probe =    serial_hsu_probe,
   
5.     .remove =    __devexit_p(serial_hsu_remove),
   
6.     .suspend =    serial_hsu_suspend,
   
7.     .resume    =    serial_hsu_resume,
   
8. };

5.  serial_hsu_probe :

1. static int serial_hsu_probe(struct pci_dev *pdev,
   
2.                 const struct pci_device_id *ent)
   
3. {
   
4.     struct uart_hsu_port *uport;
   
5.     int index, ret;
   
6. 
   
7.     printk(KERN_INFO "HSU: found PCI Serial controller(ID: %04x:%04x)\n",
   
8.         pdev->vendor, pdev->device);
   
9. 
   
10.     switch (pdev->device) {
    
11.     case 0x081B:
    
12.         index = 0;
    
13.         break;
    
14.     case 0x081C:
    
15.         index = 1;
    
16.         break;
    
17.     case 0x081D:
    
18.         index = 2;
    
19.         break;
    
20.     case 0x081E:
    
21.         /* internal DMA controller */
    
22.         index = 3;
    
23.         break;
    
24.     default:
    
25.         dev_err(&pdev->dev, "HSU: out of index!");
    
26.         return -ENODEV;
    
27.     }
    
28. 
    
29.     ret = pci_enable_device(pdev);
    
30.     if (ret)
    
31.         return ret;
    
32. 
    
33.     if (index == 3) {
    
34.         /* DMA controller */
    
35.         ret = request_irq(pdev->irq, dma_irq, 0, "hsu_dma", phsu);
    
36.         if (ret) {
    
37.             dev_err(&pdev->dev, "can not get IRQ\n");
    
38.             goto err_disable;
    
39.         }
    
40.         pci_set_drvdata(pdev, phsu);
    
41.     } else {
    
42.         /* UART port 0~2 */
    
43.         uport = &phsu->port[index];
    
44.         uport->port.irq = pdev->irq;
    
45.         uport->port.dev = &pdev->dev;
    
46.         uport->dev = &pdev->dev;
    
47. 
    
48.         ret = request_irq(pdev->irq, port_irq, 0, uport->name, uport);
    
49.         if (ret) {
    
50.             dev_err(&pdev->dev, "can not get IRQ\n");
    
51.             goto err_disable;
    
52.         }
    
53.         uart_add_one_port(&serial_hsu_reg, &uport->port);
    
54. 
    
55. #ifdef CONFIG_SERIAL_MFD_HSU_CONSOLE
    
56.         if (index == 1) {
    
57.             register_console(&serial_hsu_console);
    
58.             uport->port.cons = &serial_hsu_console;
    
59.         }
    
60. #endif
    
61.         pci_set_drvdata(pdev, uport);
    
62.     }
    
63. 
    
64.     return 0;
    
65. 
    
66. err_disable:
    
67.     pci_disable_device(pdev);
    
68.     return ret;
    
69. }

serial_hsu_suspend() 和 serial_hsu_resume().
 

1. #ifdef CONFIG_PM
   
2. static int serial_hsu_suspend(struct pci_dev *pdev, pm_message_t state)
   
3. {
   
4.     void *priv = pci_get_drvdata(pdev);
   
5.     struct uart_hsu_port *up;
   
6. 
   
7.     /* Make sure this is not the internal dma controller */
   
8.     if (priv && (pdev->device != 0x081E)) {
   
9.         up = priv;
   
10.         uart_suspend_port(&serial_hsu_reg, &up->port);
    
11.     }
    
12. 
    
13.     pci_save_state(pdev);
    
14.     pci_set_power_state(pdev, pci_choose_state(pdev, state));
    
15.         return 0;
    
16. }
    
17. 
    
18. static int serial_hsu_resume(struct pci_dev *pdev)
    
19. {
    
20.     void *priv = pci_get_drvdata(pdev);
    
21.     struct uart_hsu_port *up;
    
22.     int ret;
    
23. 
    
24.     pci_set_power_state(pdev, PCI_D0);
    
25.     pci_restore_state(pdev);
    
26. 
    
27.     ret = pci_enable_device(pdev);
    
28.     if (ret)
    
29.         dev_warn(&pdev->dev,
    
30.             "HSU: can't re-enable device, try to continue\n");
    
31. 
    
32.     if (priv && (pdev->device != 0x081E)) {
    
33.         up = priv;
    
34.         uart_resume_port(&serial_hsu_reg, &up->port);
    
35.     }
    
36.     return 0;
    
37. }
    
38. #else
    
39. #define serial_hsu_suspend    NULL
    
40. #define serial_hsu_resume    NULL
    
41. #endif

6 . serial_hsu_pops, 实现了 serial hsu 的各种串口操作。

1. struct uart_ops serial_hsu_pops = {
   
2.     .tx_empty    = serial_hsu_tx_empty,
   
3.     .set_mctrl    = serial_hsu_set_mctrl,
   
4.     .get_mctrl    = serial_hsu_get_mctrl,
   
5.     .stop_tx    = serial_hsu_stop_tx,
   
6.     .start_tx    = serial_hsu_start_tx,
   
7.     .stop_rx    = serial_hsu_stop_rx,
   
8.     .enable_ms    = serial_hsu_enable_ms,
   
9.     .break_ctl    = serial_hsu_break_ctl,
   
10.     .startup    = serial_hsu_startup,
    
11.     .shutdown    = serial_hsu_shutdown,
    
12.     .set_termios    = serial_hsu_set_termios,
    
13.     .pm        = serial_hsu_pm,
    
14.     .type        = serial_hsu_type,
    
15.     .release_port    = serial_hsu_release_port,
    
16.     .request_port    = serial_hsu_request_port,
    
17.     .config_port    = serial_hsu_config_port,
    
18.     .verify_port    = serial_hsu_verify_port,
    
19. };

7. serial_hsu_console 结构体, 实现了console功能，注意里面有个 serail_hsu_reg

1. tatic struct console serial_hsu_console = {
   
2.     .name        = "ttyMFD",
   
3.     .write        = serial_hsu_console_write,
   
4.     .device        = uart_console_device,
   
5.     .setup        = serial_hsu_console_setup,
   
6.     .flags        = CON_PRINTBUFFER,
   
7.     .index        = 1,
   
8.     .data        = &serial_hsu_reg,       //串口 hsu 信息数据
   
9. };
   
10. #endif

1. static void serial_hsu_console_putchar(struct uart_port *port, int ch)
   
2. {
   
3.     struct uart_hsu_port *up =
   
4.         container_of(port, struct uart_hsu_port, port);
   
5. 
   
6.     wait_for_xmitr(up);
   
7.     serial_out(up, UART_TX, ch);
   
8. }
   
9. 
   
10. /*
    
11.  * Print a string to the serial port trying not to disturb
    
12.  * any possible real use of the port...
    
13.  *
    
14.  *    The console_lock must be held when we get here.
    
15.  */
    
16. static void
    
17. serial_hsu_console_write(struct console *co, const char *s, unsigned int count)
    
18. {
    
19.     struct uart_hsu_port *up = serial_hsu_ports[co->index];
    
20.     unsigned long flags;
    
21.     unsigned int ier;
    
22.     int locked = 1;
    
23. 
    
24.     local_irq_save(flags);
    
25.     if (up->port.sysrq)
    
26.         locked = 0;
    
27.     else if (oops_in_progress) {
    
28.         locked = spin_trylock(&up->port.lock);
    
29.     } else
    
30.         spin_lock(&up->port.lock);
    
31. 
    
32.     /* First save the IER then disable the interrupts */
    
33.     ier = serial_in(up, UART_IER);
    
34.     serial_out(up, UART_IER, 0);
    
35. 
    
36.     uart_console_write(&up->port, s, count, serial_hsu_console_putchar);
    
37. 
    
38.     /*
    
39.      * Finally, wait for transmitter to become empty
    
40.      * and restore the IER
    
41.      */
    
42.     wait_for_xmitr(up);
    
43.     serial_out(up, UART_IER, ier);
    
44. 
    
45.     if (locked)
    
46.         spin_unlock(&up->port.lock);
    
47.     local_irq_restore(flags);
    
48. }
    
49. 
    
50. static struct console serial_hsu_console;
    
51. 
    
52. static int __init
    
53. serial_hsu_console_setup(struct console *co, char *options)
    
54. {
    
55.     struct uart_hsu_port *up;
    
56.     int baud = 115200;
    
57.     int bits = 8;
    
58.     int parity = 'n';
    
59.     int flow = 'n';
    
60.     int ret;
    
61. 
    
62.     if (co->index == -1 || co->index >= serial_hsu_reg.nr)
    
63.         co->index = 0;
    
64.     up = serial_hsu_ports[co->index];
    
65.     if (!up)
    
66.         return -ENODEV;
    
67. 
    
68.     if (options)
    
69.         uart_parse_options(options, &baud, &parity, &bits, &flow);
    
70. 
    
71.     ret = uart_set_options(&up->port, co, baud, parity, bits, flow);
    
72. 
    
73.     return ret;
    
74. }