examples/tty/serial.c
changeset 1615 020ad9ad3afb
parent 1614 2f362d2b6d6e
child 1779 9fab229d6ca9
equal deleted inserted replaced
1614:2f362d2b6d6e 1615:020ad9ad3afb
    49     SER_WAIT_FOR_INIT_RESPONSE,
    49     SER_WAIT_FOR_INIT_RESPONSE,
    50     SER_READY
    50     SER_READY
    51 } serial_state_t;
    51 } serial_state_t;
    52 
    52 
    53 typedef struct {
    53 typedef struct {
       
    54     struct list_head list;
       
    55 
    54     ec_tty_t *tty;
    56     ec_tty_t *tty;
    55     ec_slave_config_t *sc;
    57     ec_slave_config_t *sc;
    56 
    58 
    57     size_t max_tx_data_size;
    59     size_t max_tx_data_size;
    58     size_t max_rx_data_size;
    60     size_t max_rx_data_size;
    74     u32 off_tx;
    76     u32 off_tx;
    75     u32 off_status;
    77     u32 off_status;
    76     u32 off_rx;
    78     u32 off_rx;
    77 } el6002_t;
    79 } el6002_t;
    78 
    80 
    79 static el6002_t *ser = NULL;
    81 LIST_HEAD(handlers);
    80         
    82         
    81 /*****************************************************************************/
    83 /*****************************************************************************/
    82 
    84 
    83 /* Beckhoff EL6002
    85 /* Beckhoff EL6002
    84  * Vendor ID:       0x00000002
    86  * Vendor ID:       0x00000002
   361 
   363 
   362 /*****************************************************************************/
   364 /*****************************************************************************/
   363 
   365 
   364 void run_serial_devices(u8 *pd)
   366 void run_serial_devices(u8 *pd)
   365 {
   367 {
   366     if (ser) {
   368     el6002_t *ser;
       
   369 
       
   370     list_for_each_entry(ser, &handlers, list) {
   367         el6002_run(ser, pd);
   371         el6002_run(ser, pd);
   368     }
   372     }
   369 }
   373 }
   370 
   374 
   371 /*****************************************************************************/
   375 /*****************************************************************************/
   373 int create_serial_devices(ec_master_t *master, ec_domain_t *domain)
   377 int create_serial_devices(ec_master_t *master, ec_domain_t *domain)
   374 {
   378 {
   375     int i, ret;
   379     int i, ret;
   376     ec_master_info_t master_info;
   380     ec_master_info_t master_info;
   377     ec_slave_info_t slave_info;
   381     ec_slave_info_t slave_info;
   378     
   382     el6002_t *ser, *next;
       
   383 
   379     printk(KERN_INFO PFX "Registering serial devices...\n");
   384     printk(KERN_INFO PFX "Registering serial devices...\n");
   380 
   385 
   381     ret = ecrt_master(master, &master_info);
   386     ret = ecrt_master(master, &master_info);
   382     if (ret) {
   387     if (ret) {
   383         printk(KERN_ERR PFX "Failed to obtain master information.\n");
   388         printk(KERN_ERR PFX "Failed to obtain master information.\n");
   384         return ret;
   389         goto out_return;
   385     }
   390     }
   386 
   391 
   387     for (i = 0; i < master_info.slave_count; i++) {
   392     for (i = 0; i < master_info.slave_count; i++) {
   388         ret = ecrt_master_get_slave(master, i, &slave_info);
   393         ret = ecrt_master_get_slave(master, i, &slave_info);
   389         if (ret) {
   394         if (ret) {
   390             printk(KERN_ERR PFX "Failed to obtain master information.\n");
   395             printk(KERN_ERR PFX "Failed to obtain slave information.\n");
   391             return ret;
   396             goto out_free_handlers;
   392         }
   397         }
   393 
   398 
   394         if (slave_info.vendor_id != VendorIdBeckhoff
   399         if (slave_info.vendor_id != VendorIdBeckhoff
   395                 || slave_info.product_code != ProductCodeBeckhoffEL6002) {
   400                 || slave_info.product_code != ProductCodeBeckhoffEL6002) {
   396             continue;
   401             continue;
   400                 " at position %i\n", i);
   405                 " at position %i\n", i);
   401 
   406 
   402         ser = kmalloc(sizeof(*ser), GFP_KERNEL);
   407         ser = kmalloc(sizeof(*ser), GFP_KERNEL);
   403         if (!ser) {
   408         if (!ser) {
   404             printk(KERN_ERR PFX "Failed to allocate serial device object.\n");
   409             printk(KERN_ERR PFX "Failed to allocate serial device object.\n");
   405             return -ENOMEM;
   410             ret = -ENOMEM;
       
   411             goto out_free_handlers;
   406         }
   412         }
   407 
   413 
   408         ret = el6002_init(ser, master, i, domain);
   414         ret = el6002_init(ser, master, i, domain);
   409         if (ret) {
   415         if (ret) {
   410             printk(KERN_ERR PFX "Failed to init serial device object.\n");
   416             printk(KERN_ERR PFX "Failed to init serial device object.\n");
   411             kfree(ser);
   417             kfree(ser);
   412             ser = NULL;
   418             goto out_free_handlers;
   413             return ret;
       
   414         }
   419         }
   415 
   420 
   416         break; // FIXME
   421         list_add_tail(&ser->list, &handlers);
   417     }
   422     }
   418 
   423 
   419 
   424 
   420     printk(KERN_INFO PFX "Finished.\n");
   425     printk(KERN_INFO PFX "Finished.\n");
   421     return 0;
   426     return 0;
   422 }
   427 
   423 
   428 out_free_handlers:
   424 /*****************************************************************************/
   429     list_for_each_entry_safe(ser, next, &handlers, list) {
   425 
   430         list_del(&ser->list);
   426 void free_serial_devices(void)
       
   427 {
       
   428     printk(KERN_INFO PFX "Cleaning up serial devices...\n");
       
   429 
       
   430     if (ser) {
       
   431         el6002_clear(ser);
   431         el6002_clear(ser);
   432         kfree(ser);
   432         kfree(ser);
   433     }
   433     }
       
   434 out_return:
       
   435     return ret;
       
   436 }
       
   437 
       
   438 /*****************************************************************************/
       
   439 
       
   440 void free_serial_devices(void)
       
   441 {
       
   442     el6002_t *ser, *next;
       
   443 
       
   444     printk(KERN_INFO PFX "Cleaning up serial devices...\n");
       
   445 
       
   446     list_for_each_entry_safe(ser, next, &handlers, list) {
       
   447         list_del(&ser->list);
       
   448         el6002_clear(ser);
       
   449         kfree(ser);
       
   450     }
   434 
   451 
   435     printk(KERN_INFO PFX "Finished cleaning up serial devices.\n");
   452     printk(KERN_INFO PFX "Finished cleaning up serial devices.\n");
   436 }
   453 }
   437 
   454 
   438 /*****************************************************************************/
   455 /*****************************************************************************/