61 } serial_state_t;

    61 } el60xx_port_state;

    75     serial_state_t state;

    72     el60xx_port_state state;

   277 int el6002_cflag_changed(void *data, tcflag_t cflag)

   282 int el60xx_cflag_changed(void *data, tcflag_t cflag)

   278 {

   283 {

   279     el6002_t *ser = (el6002_t *) data;

   284     el60xx_port_t *port = (el60xx_port_t *) data;

   288     printk(KERN_INFO PFX "%s(data=%p, cflag=%x).\n", __func__, ser, cflag);

   293     printk(KERN_INFO PFX "%s(data=%p, cflag=%x).\n", __func__, port, cflag);

   359     ser->requested_rtscts = rtscts != 0;

   364     port->requested_rtscts = rtscts != 0;

   360     ser->requested_baud_rate = b_to_use->value;

   365     port->requested_baud_rate = b_to_use->value;

   361     ser->requested_data_frame = df_to_use->value;

   366     port->requested_data_frame = df_to_use->value;

   362     ser->config_error = 0;

   367     port->config_error = 0;

   368 int el6002_init(el6002_t *ser, ec_master_t *master, u16 position,

   373 int el60xx_port_init(el60xx_port_t *port, ec_slave_config_t *sc,

   374         ec_domain_t *domain, unsigned int slot_offset)

   375 {

   376     int ret = 0;

   377 

   378     port->tty = ectty_create(el60xx_cflag_changed, port);

   379     if (IS_ERR(port->tty)) {

   380         printk(KERN_ERR PFX "Failed to create tty.\n");

   381         ret = PTR_ERR(port->tty);

   382         goto out_return;

   383     }

   384 

   385     port->max_tx_data_size = 22;

   386     port->max_rx_data_size = 22;

   387     port->tx_data = NULL;

   388     port->tx_data_size = 0;

   389     port->state = SER_REQUEST_INIT;

   390     port->tx_request_toggle = 0;

   391     port->rx_accepted_toggle = 0;

   392     port->control = 0x0000;

   393     port->off_ctrl = 0;

   394     port->off_tx = 0;

   395     port->off_status = 0;

   396     port->off_rx = 0;

   397     port->requested_rtscts = 0x00; // no hardware handshake

   398     port->current_rtscts = 0xff;

   399     port->requested_baud_rate = 6; // 9600

   400     port->current_baud_rate = 0;

   401     port->requested_data_frame = 0x03; // 8N1

   402     port->current_data_frame = 0x00;

   403     port->config_error = 0;

   404 

   405     if (!(port->rtscts_sdo = ecrt_slave_config_create_sdo_request(sc,

   406                     0x8000 + slot_offset, 0x01, 1))) {

   407         printk(KERN_ERR PFX "Failed to create SDO request.\n");

   408         ret = -ENOMEM;

   409         goto out_free_tty;

   410     }

   411 

   412     if (!(port->baud_sdo = ecrt_slave_config_create_sdo_request(sc,

   413                     0x8000 + slot_offset, 0x11, 1))) {

   414         printk(KERN_ERR PFX "Failed to create SDO request.\n");

   415         ret = -ENOMEM;

   416         goto out_free_tty;

   417     }

   418 

   419     if (!(port->frame_sdo = ecrt_slave_config_create_sdo_request(sc,

   420                     0x8000 + slot_offset, 0x15, 1))) {

   421         printk(KERN_ERR PFX "Failed to create SDO request.\n");

   422         ret = -ENOMEM;

   423         goto out_free_tty;

   424     }

   425 

   426     ret = ecrt_slave_config_reg_pdo_entry(

   427             sc, 0x7001 + slot_offset, 0x01, domain, NULL);

   428     if (ret < 0) {

   429         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   430         goto out_free_tty;

   431     }

   432     port->off_ctrl = ret;

   433 

   434     ret = ecrt_slave_config_reg_pdo_entry(

   435             sc, 0x7000 + slot_offset, 0x11, domain, NULL);

   436     if (ret < 0) {

   437         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   438         goto out_free_tty;

   439     }

   440     port->off_tx = ret;

   441 

   442     ret = ecrt_slave_config_reg_pdo_entry(

   443             sc, 0x6001 + slot_offset, 0x01, domain, NULL);

   444     if (ret < 0) {

   445         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   446         goto out_free_tty;

   447     }

   448     port->off_status = ret;

   449 

   450     ret = ecrt_slave_config_reg_pdo_entry(

   451             sc, 0x6000 + slot_offset, 0x11, domain, NULL);

   452     if (ret < 0) {

   453         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   454         goto out_free_tty;

   455     }

   456     port->off_rx = ret;

   457 

   458     if (port->max_tx_data_size > 0) {

   459         port->tx_data = kmalloc(port->max_tx_data_size, GFP_KERNEL);

   460         if (port->tx_data == NULL) {

   461             ret = -ENOMEM;

   462             goto out_free_tty;

   463         }

   464     }

   465 

   466     return 0;

   467 

   468 out_free_tty:

   469     ectty_free(port->tty);

   470 out_return:

   471     return ret;

   472 }

   473 

   474 /****************************************************************************/

   475 

   476 void el60xx_port_clear(el60xx_port_t *port)

   477 {

   478     ectty_free(port->tty);

   479     if (port->tx_data) {

   480         kfree(port->tx_data);

   481     }

   482 }

   483 

   484 /****************************************************************************/

   485 

   486 void el60xx_port_run(el60xx_port_t *port, u8 *pd)

   487 {

   488     u16 status = EC_READ_U16(pd + port->off_status);

   489     u8 *rx_data = pd + port->off_rx;

   490     uint8_t tx_accepted_toggle, rx_request_toggle;

   491 

   492     switch (port->state) {

   493         case SER_READY:

   494 

   495             /* Check, if hardware handshaking has to be configured. */

   496             if (!port->config_error &&

   497                     port->requested_rtscts != port->current_rtscts) {

   498                 EC_WRITE_U8(ecrt_sdo_request_data(port->rtscts_sdo),

   499                         port->requested_rtscts);

   500                 ecrt_sdo_request_write(port->rtscts_sdo);

   501                 port->state = SER_SET_RTSCTS;

   502                 break;

   503             }

   504 

   505             /* Check, if the baud rate has to be configured. */

   506             if (!port->config_error &&

   507                     port->requested_baud_rate != port->current_baud_rate) {

   508                 EC_WRITE_U8(ecrt_sdo_request_data(port->baud_sdo),

   509                         port->requested_baud_rate);

   510                 ecrt_sdo_request_write(port->baud_sdo);

   511                 port->state = SER_SET_BAUD_RATE;

   512                 break;

   513             }

   514 

   515             /* Check, if the data frame has to be configured. */

   516             if (!port->config_error &&

   517                     port->requested_data_frame != port->current_data_frame) {

   518                 EC_WRITE_U8(ecrt_sdo_request_data(port->frame_sdo),

   519                         port->requested_data_frame);

   520                 ecrt_sdo_request_write(port->frame_sdo);

   521                 port->state = SER_SET_DATA_FRAME;

   522                 break;

   523             }

   524 

   525             /* Send data */

   526             

   527             tx_accepted_toggle = status & 0x0001;

   528             if (tx_accepted_toggle != port->tx_accepted_toggle) { // ready

   529                 port->tx_data_size =

   530                     ectty_tx_data(port->tty, port->tx_data, port->max_tx_data_size);

   531                 if (port->tx_data_size) {

   532 #if DEBUG

   533                     printk(KERN_INFO PFX "Sending %u bytes.\n", port->tx_data_size);

   534 #endif

   535                     port->tx_request_toggle = !port->tx_request_toggle;

   536                     port->tx_accepted_toggle = tx_accepted_toggle;

   537                 }

   538             }

   539 

   540             /* Receive data */

   541 

   542             rx_request_toggle = status & 0x0002;

   543             if (rx_request_toggle != port->rx_request_toggle) {

   544                 uint8_t rx_data_size = status >> 8;

   545                 port->rx_request_toggle = rx_request_toggle;

   546 #if DEBUG

   547                 printk(KERN_INFO PFX "Received %u bytes.\n", rx_data_size);

   548 #endif

   549                 ectty_rx_data(port->tty, rx_data, rx_data_size);

   550                 port->rx_accepted_toggle = !port->rx_accepted_toggle;

   551             }

   552 

   553             port->control =

   554                 port->tx_request_toggle |

   555                 port->rx_accepted_toggle << 1 |

   556                 port->tx_data_size << 8;

   557             break;

   558 

   559         case SER_REQUEST_INIT:

   560             if (status & (1 << 2)) {

   561                 port->control = 0x0000;

   562                 port->state = SER_WAIT_FOR_INIT_RESPONSE;

   563             } else {

   564                 port->control = 1 << 2; // CW.2, request initialization

   565             }

   566             break;

   567 

   568         case SER_WAIT_FOR_INIT_RESPONSE:

   569             if (!(status & (1 << 2))) {

   570                 printk(KERN_INFO PFX "EL600x init successful.\n");

   571                 port->tx_accepted_toggle = 1;

   572                 port->control = 0x0000;

   573                 port->state = SER_READY;

   574             }

   575             break;

   576 

   577         case SER_SET_RTSCTS:

   578             switch (ecrt_sdo_request_state(port->rtscts_sdo)) {

   579                 case EC_REQUEST_SUCCESS:

   580                     printk(KERN_INFO PFX "Slave accepted RTS/CTS.\n");

   581                     port->current_rtscts = port->requested_rtscts;

   582                     port->state = SER_REQUEST_INIT;

   583                     break;

   584                 case EC_REQUEST_ERROR:

   585                     printk(KERN_INFO PFX "Failed to set RTS/CTS!\n");

   586                     port->state = SER_REQUEST_INIT;

   587                     port->config_error = 1;

   588                     break;

   589                 default:

   590                     break;

   591             }

   592             break;

   593 

   594         case SER_SET_BAUD_RATE:

   595             switch (ecrt_sdo_request_state(port->baud_sdo)) {

   596                 case EC_REQUEST_SUCCESS:

   597                     printk(KERN_INFO PFX "Slave accepted baud rate.\n");

   598                     port->current_baud_rate = port->requested_baud_rate;

   599                     port->state = SER_REQUEST_INIT;

   600                     break;

   601                 case EC_REQUEST_ERROR:

   602                     printk(KERN_INFO PFX "Failed to set baud rate!\n");

   603                     port->state = SER_REQUEST_INIT;

   604                     port->config_error = 1;

   605                     break;

   606                 default:

   607                     break;

   608             }

   609             break;

   610 

   611         case SER_SET_DATA_FRAME:

   612             switch (ecrt_sdo_request_state(port->frame_sdo)) {

   613                 case EC_REQUEST_SUCCESS:

   614                     printk(KERN_INFO PFX "Slave accepted data frame.\n");

   615                     port->current_data_frame = port->requested_data_frame;

   616                     port->state = SER_REQUEST_INIT;

   617                     break;

   618                 case EC_REQUEST_ERROR:

   619                     printk(KERN_INFO PFX "Failed to set data frame!\n");

   620                     port->state = SER_REQUEST_INIT;

   621                     port->config_error = 1;

   622                     break;

   623                 default:

   624                     break;

   625             }

   626             break;

   627     }

   628 

   629     EC_WRITE_U16(pd + port->off_ctrl, port->control);

   630     memcpy(pd + port->off_tx, port->tx_data, port->tx_data_size);

   631 }

   632 

   633 /****************************************************************************/

   634 

   635 int el6002_init(el6002_t *el6002, ec_master_t *master, u16 position,

   371     int ret = 0;

   638     int ret = 0, i;

   372 

   639 

   373     ser->tty = ectty_create(el6002_cflag_changed, ser);

   640     if (!(el6002->sc = ecrt_master_slave_config(

   374     if (IS_ERR(ser->tty)) {

   375         printk(KERN_ERR PFX "Failed to create tty.\n");

   376         ret = PTR_ERR(ser->tty);

   377         goto out_return;

   378     }

   379 

   380     ser->sc = NULL;

   381     ser->max_tx_data_size = 22;

   382     ser->max_rx_data_size = 22;

   383     ser->tx_data = NULL;

   384     ser->tx_data_size = 0;

   385     ser->state = SER_REQUEST_INIT;

   386     ser->tx_request_toggle = 0;

   387     ser->rx_accepted_toggle = 0;

   388     ser->control = 0x0000;

   389     ser->off_ctrl = 0;

   390     ser->off_tx = 0;

   391     ser->off_status = 0;

   392     ser->off_rx = 0;

   393     ser->requested_rtscts = 0x00; // no hardware handshake

   394     ser->current_rtscts = 0xff;

   395     ser->requested_baud_rate = 6; // 9600

   396     ser->current_baud_rate = 0;

   397     ser->requested_data_frame = 0x03; // 8N1

   398     ser->current_data_frame = 0x00;

   399     ser->config_error = 0;

   400 

   401     if (!(ser->sc = ecrt_master_slave_config(

   405         goto out_free_tty;

   644         goto out_return;

   406     }

   645     }

   407 

   646 

   408     if (!(ser->rtscts_sdo = ecrt_slave_config_create_sdo_request(ser->sc,

   647     if (ecrt_slave_config_pdos(el6002->sc, EC_END, el6002_syncs)) {

   409                     0x8000, 0x01, 1))) {

   410         printk(KERN_ERR PFX "Failed to create SDO request.\n");

   411         ret = -ENOMEM;

   412         goto out_free_tty;

   413     }

   414 

   415     if (!(ser->baud_sdo = ecrt_slave_config_create_sdo_request(ser->sc,

   416                     0x8000, 0x11, 1))) {

   417         printk(KERN_ERR PFX "Failed to create SDO request.\n");

   418         ret = -ENOMEM;

   419         goto out_free_tty;

   420     }

   421 

   422     if (!(ser->frame_sdo = ecrt_slave_config_create_sdo_request(ser->sc,

   423                     0x8000, 0x15, 1))) {

   424         printk(KERN_ERR PFX "Failed to create SDO request.\n");

   425         ret = -ENOMEM;

   426         goto out_free_tty;

   427     }

   428 

   429     if (ecrt_slave_config_pdos(ser->sc, EC_END, el6002_syncs)) {

   432         goto out_free_tty;

   650         goto out_return;

   433     }

   651     }

   434     

   652 

   435     ret = ecrt_slave_config_reg_pdo_entry(

   653     for (i = 0; i < EL6002_PORTS; i++) {

   436             ser->sc, 0x7001, 0x01, domain, NULL);

   654         if (el60xx_port_init(el6002->port + i, el6002->sc, domain, i * 0x10)) {

   437     if (ret < 0) {

   655             printk(KERN_ERR PFX "Failed to init port X%u.\n", i);

   438         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   656             goto out_ports;

   439         goto out_free_tty;

   440     }

   441     ser->off_ctrl = ret;

   442 

   443     ret = ecrt_slave_config_reg_pdo_entry(

   444             ser->sc, 0x7000, 0x11, domain, NULL);

   445     if (ret < 0) {

   446         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   447         goto out_free_tty;

   448     }

   449     ser->off_tx = ret;

   450 

   451     ret = ecrt_slave_config_reg_pdo_entry(

   452             ser->sc, 0x6001, 0x01, domain, NULL);

   453     if (ret < 0) {

   454         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   455         goto out_free_tty;

   456     }

   457     ser->off_status = ret;

   458 

   459     ret = ecrt_slave_config_reg_pdo_entry(

   460             ser->sc, 0x6000, 0x11, domain, NULL);

   461     if (ret < 0) {

   462         printk(KERN_ERR PFX "Failed to register PDO entry.\n");

   463         goto out_free_tty;

   464     }

   465     ser->off_rx = ret;

   466 

   467     if (ser->max_tx_data_size > 0) {

   468         ser->tx_data = kmalloc(ser->max_tx_data_size, GFP_KERNEL);

   469         if (ser->tx_data == NULL) {

   470             ret = -ENOMEM;

   471             goto out_free_tty;

   477 out_free_tty:

   662 out_ports:

   478     ectty_free(ser->tty);

   663     for (i--; i <= 0; i--) {

   664         el60xx_port_clear(el6002->port + i);

   665     }

   485 void el6002_clear(el6002_t *ser)

   672 void el6002_clear(el6002_t *el6002)

   486 {

   673 {

   487     ectty_free(ser->tty);

   674     int i;

   488     if (ser->tx_data) {

   675 

   489         kfree(ser->tx_data);

   676     for (i = 0; i < EL6002_PORTS; i++) {

   677         el60xx_port_clear(el6002->port + i);

   495 void el6002_run(el6002_t *ser, u8 *pd)

   683 void el6002_run(el6002_t *el6002, u8 *pd)

   496 {

   684 {

   497     u16 status = EC_READ_U16(pd + ser->off_status);

   685     int i;

   498     u8 *rx_data = pd + ser->off_rx;

   686 

   499     uint8_t tx_accepted_toggle, rx_request_toggle;

   687     for (i = 0; i < EL6002_PORTS; i++) {

   500 

   688         el60xx_port_run(el6002->port + i, pd);

   501     switch (ser->state) {

   689     }

   502         case SER_READY:

   503 

   504             /* Check, if hardware handshaking has to be configured. */

   505             if (!ser->config_error &&

   506                     ser->requested_rtscts != ser->current_rtscts) {

   507                 EC_WRITE_U8(ecrt_sdo_request_data(ser->rtscts_sdo),

   508                         ser->requested_rtscts);

   509                 ecrt_sdo_request_write(ser->rtscts_sdo);

   510                 ser->state = SER_SET_RTSCTS;

   511                 break;

   512             }

   513 

   514             /* Check, if the baud rate has to be configured. */

   515             if (!ser->config_error &&

   516                     ser->requested_baud_rate != ser->current_baud_rate) {

   517                 EC_WRITE_U8(ecrt_sdo_request_data(ser->baud_sdo),

   518                         ser->requested_baud_rate);

   519                 ecrt_sdo_request_write(ser->baud_sdo);

   520                 ser->state = SER_SET_BAUD_RATE;

   521                 break;

   522             }

   523 

   524             /* Check, if the data frame has to be configured. */

   525             if (!ser->config_error &&

   526                     ser->requested_data_frame != ser->current_data_frame) {

   527                 EC_WRITE_U8(ecrt_sdo_request_data(ser->frame_sdo),

   528                         ser->requested_data_frame);

   529                 ecrt_sdo_request_write(ser->frame_sdo);

   530                 ser->state = SER_SET_DATA_FRAME;

   531                 break;

   532             }

   533 

   534             /* Send data */

   535             

   536             tx_accepted_toggle = status & 0x0001;

   537             if (tx_accepted_toggle != ser->tx_accepted_toggle) { // ready

   538                 ser->tx_data_size =

   539                     ectty_tx_data(ser->tty, ser->tx_data, ser->max_tx_data_size);

   540                 if (ser->tx_data_size) {

   541 #if DEBUG

   542                     printk(KERN_INFO PFX "Sending %u bytes.\n", ser->tx_data_size);

   543 #endif

   544                     ser->tx_request_toggle = !ser->tx_request_toggle;

   545                     ser->tx_accepted_toggle = tx_accepted_toggle;

   546                 }

   547             }

   548 

   549             /* Receive data */

   550 

   551             rx_request_toggle = status & 0x0002;

   552             if (rx_request_toggle != ser->rx_request_toggle) {

   553                 uint8_t rx_data_size = status >> 8;

   554                 ser->rx_request_toggle = rx_request_toggle;

   555 #if DEBUG

   556                 printk(KERN_INFO PFX "Received %u bytes.\n", rx_data_size);

   557 #endif

   558                 ectty_rx_data(ser->tty, rx_data, rx_data_size);

   559                 ser->rx_accepted_toggle = !ser->rx_accepted_toggle;

   560             }

   561 

   562             ser->control =

   563                 ser->tx_request_toggle |

   564                 ser->rx_accepted_toggle << 1 |

   565                 ser->tx_data_size << 8;

   566             break;

   567 

   568         case SER_REQUEST_INIT:

   569             if (status & (1 << 2)) {

   570                 ser->control = 0x0000;

   571                 ser->state = SER_WAIT_FOR_INIT_RESPONSE;

   572             } else {

   573                 ser->control = 1 << 2; // CW.2, request initialization

   574             }

   575             break;

   576 

   577         case SER_WAIT_FOR_INIT_RESPONSE:

   578             if (!(status & (1 << 2))) {

   579                 printk(KERN_INFO PFX "EL600x init successful.\n");

   580                 ser->tx_accepted_toggle = 1;

   581                 ser->control = 0x0000;

   582                 ser->state = SER_READY;

   583             }

   584             break;

   585 

   586         case SER_SET_RTSCTS:

   587             switch (ecrt_sdo_request_state(ser->rtscts_sdo)) {

   588                 case EC_REQUEST_SUCCESS:

   589                     printk(KERN_INFO PFX "Slave accepted RTS/CTS.\n");

   590                     ser->current_rtscts = ser->requested_rtscts;

   591                     ser->state = SER_REQUEST_INIT;

   592                     break;

   593                 case EC_REQUEST_ERROR:

   594                     printk(KERN_INFO PFX "Failed to set RTS/CTS!\n");

   595                     ser->state = SER_REQUEST_INIT;

   596                     ser->config_error = 1;

   597                     break;

   598                 default:

   599                     break;

   600             }

   601             break;

   602 

   603         case SER_SET_BAUD_RATE:

   604             switch (ecrt_sdo_request_state(ser->baud_sdo)) {

   605                 case EC_REQUEST_SUCCESS:

   606                     printk(KERN_INFO PFX "Slave accepted baud rate.\n");

   607                     ser->current_baud_rate = ser->requested_baud_rate;

   608                     ser->state = SER_REQUEST_INIT;

   609                     break;

   610                 case EC_REQUEST_ERROR:

   611                     printk(KERN_INFO PFX "Failed to set baud rate!\n");

   612                     ser->state = SER_REQUEST_INIT;

   613                     ser->config_error = 1;

   614                     break;

   615                 default:

   616                     break;

   617             }

   618             break;

   619 

   620         case SER_SET_DATA_FRAME:

   621             switch (ecrt_sdo_request_state(ser->frame_sdo)) {

   622                 case EC_REQUEST_SUCCESS:

   623                     printk(KERN_INFO PFX "Slave accepted data frame.\n");

   624                     ser->current_data_frame = ser->requested_data_frame;

   625                     ser->state = SER_REQUEST_INIT;

   626                     break;

   627                 case EC_REQUEST_ERROR:

   628                     printk(KERN_INFO PFX "Failed to set data frame!\n");

   629                     ser->state = SER_REQUEST_INIT;

   630                     ser->config_error = 1;

   631                     break;

   632                 default:

   633                     break;

   634             }

   635             break;

   636     }

   637 

   638     EC_WRITE_U16(pd + ser->off_ctrl, ser->control);

   639     memcpy(pd + ser->off_tx, ser->tx_data, ser->tx_data_size);

   646     el6002_t *ser;

   696     el6002_t *el6002;

   647 

   697 

   648     list_for_each_entry(ser, &handlers, list) {

   698     list_for_each_entry(el6002, &handlers, list) {

   649         el6002_run(ser, pd);

   699         el6002_run(el6002, pd);

   658     el6002_t *ser;

   708     el6002_t *el6002;

   664     ser = kmalloc(sizeof(*ser), GFP_KERNEL);

   714     el6002 = kmalloc(sizeof(*el6002), GFP_KERNEL);

   665     if (!ser) {

   715     if (!el6002) {

   670     ret = el6002_init(ser, master, position, domain, vendor, product);

   720     ret = el6002_init(el6002, master, position, domain, vendor, product);

   673         kfree(ser);

   723         kfree(el6002);

   677     list_add_tail(&ser->list, &handlers);

   727     list_add_tail(&el6002->list, &handlers);