linux设备模型之uart驱动架构分析

01

int

uart_register_driver(

struct

uart_driver
 *drv)

02

{

03

struct

tty_driver
 *normal = NULL;

04

int

i,
 retval;

05

06

BUG_ON(drv->state);

07

08

/*

09

*
 Maybe we should be using a slab cache for this, especially if

10

*
 we have a large number of ports to handle.

11

*/

12

drv->state
 = kzalloc(

sizeof

(

struct

uart_state)
 * drv->nr, GFP_KERNEL);

13

retval
 = -ENOMEM;

14

if

(!drv->state)

15

goto

out;

16

17

normal 
 = alloc_tty_driver(drv->nr);

18

if

(!normal)

19

goto

out;

20

21

drv->tty_driver
 = normal;

22

23

normal->owner
 = drv->owner;

24

normal->driver_name   
 = drv->driver_name;

25

normal->name 
 = drv->dev_name;

26

normal->major
 = drv->major;

27

normal->minor_start   
 = drv->minor;

28

normal->type 
 = TTY_DRIVER_TYPE_SERIAL;

29

normal->subtype  
 = SERIAL_TYPE_NORMAL;

30

normal->init_termios  
 = tty_std_termios;

31

normal->init_termios.c_cflag
 = B9600 | CS8 | CREAD | HUPCL | CLOCAL;

32

normal->init_termios.c_ispeed
 = normal->init_termios.c_ospeed = 9600;

33

normal->flags
 = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

34

normal->driver_state   
 = drv;

35

tty_set_operations(normal,
 &uart_ops);

36

37

/*

38

*
 Initialise the UART state(s).

39

*/

40

for

(i
 = 0; i nr; i++) {

41

struct

uart_state
 *state = drv->state + i;

42

43

state->close_delay    
 = 500;

/*
 .5 seconds */

44

state->closing_wait   
 = 30000;

/*
 30 seconds */

45

46

mutex_init(&state->mutex);

47

}

48

49

retval
 = tty_register_driver(normal);

50

out:

51

if

(retval

52

put_tty_driver(normal);

53

kfree(drv->state);

54

}

55

return

retval;

56

}

01

int

uart_add_one_port(

struct

uart_driver
 *drv,

struct

uart_port
 *port)

02

{

03

struct

uart_state
 *state;

04

int

ret
 = 0;

05

struct

device
 *tty_dev;

06

07

BUG_ON(in_interrupt());

08

09

if

(port->line
 >= drv->nr)

10

return

-EINVAL;

11

12

state
 = drv->state + port->line;

13

14

mutex_lock(&port_mutex);

15

mutex_lock(&state->mutex);

16

if

(state->port)
 {

17

ret
 = -EINVAL;

18

goto

out;

19

}

20

21

state->port
 = port;

22

state->pm_state
 = -1;

23

24

port->cons
 = drv->cons;

25

port->info
 = state->info;

26

27

/*

28

*
 If this port is a console, then the spinlock is already

29

*
 initialised.

30

*/

31

if

(!(uart_console(port)
 && (port->cons->flags & CON_ENABLED))) {

32

spin_lock_init(&port->lock);

33

lockdep_set_class(&port->lock,
 &port_lock_key);

34

}

35

36

uart_configure_port(drv,
 state, port);

37

38

/*

39

*
 Register the port whether it's detected or not.  This allows

40

*
 setserial to be used to alter this ports parameters.

41

*/

42

tty_dev
 = tty_register_device(drv->tty_driver, port->line, port->dev);

43

if

(likely(!IS_ERR(tty_dev)))
 {

44

device_can_wakeup(tty_dev)
 = 1;

45

device_set_wakeup_enable(tty_dev,
 0);

46

}

else

47

printk(KERN_ERR

"Cannot
 register tty device on line %d\n"

,

48

port->line);

49

50

/*

51

*
 Ensure UPF_DEAD is not set.

52

*/

53

port->flags
 &= ~UPF_DEAD;

54

55

out:

56

mutex_unlock(&state->mutex);

57

mutex_unlock(&port_mutex);

58

59

return

ret;

60

}