Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
drivers/ec_master.c
changeset 42 a22a202d0f42
parent 39 6965c23a6826
child 43 35120a61d55e
equal deleted inserted replaced
41:42c66194c0c8 42:a22a202d0f42 
    20 /*****************************************************************************/
 
    20 /*****************************************************************************/
 
    21 
    21 
    22 /**
 
    22 /**
 
    23    Konstruktor des EtherCAT-Masters.
 
    23    Konstruktor des EtherCAT-Masters.
 
    24 
    24 
    25    @param master Zeiger auf den zu initialisierenden
 
    25    @param master Zeiger auf den zu initialisierenden EtherCAT-Master
 
    26    EtherCAT-Master
 
       
    27 
       
    28    @return 0 bei Erfolg, sonst < 0 (= dev ist NULL)
 
       
    29 */
 
    26 */
 
    30 
    27 
    31 void EtherCAT_master_init(EtherCAT_master_t *master)
 
    28 void EtherCAT_master_init(EtherCAT_master_t *master)
 
    32 {
 
    29 {
 
    33   master->slaves = NULL;
 
       
    34   master->slave_count = 0;
 
       
    35   master->dev = NULL;
 
    30   master->dev = NULL;
 
    36   master->command_index = 0x00;
 
    31   master->command_index = 0x00;
 
    37   master->tx_data_length = 0;
 
    32   master->tx_data_length = 0;
 
    38   master->process_data = NULL;
 
    33   master->rx_data_length = 0;
 
    39   master->process_data_length = 0;
 
    34   master->domain_count = 0;
 
    40   master->debug_level = 0;
 
    35   master->debug_level = 0;
 
       
    36   master->tx_time = 0;
 
       
    37   master->rx_time = 0;
 
       
    38   master->rx_tries = 0;
 
    41 }
 
    39 }
 
    42 
    40 
    43 /*****************************************************************************/
 
    41 /*****************************************************************************/
 
    44 
    42 
    45 /**
 
    43 /**
 
    51    @param master Zeiger auf den zu löschenden Master
 
    49    @param master Zeiger auf den zu löschenden Master
 
    52 */
 
    50 */
 
    53 
    51 
    54 void EtherCAT_master_clear(EtherCAT_master_t *master)
 
    52 void EtherCAT_master_clear(EtherCAT_master_t *master)
 
    55 {
 
    53 {
 
    56   // Remove all slaves
 
    54   unsigned int i;
 
    57   EtherCAT_clear_slaves(master);
 
    55 
    58 
    56   // Remove domains
 
    59   if (master->process_data) {
 
    57   for (i = 0; i < master->domain_count; i++) {
 
    60     kfree(master->process_data);
 
    58     EtherCAT_domain_clear(master->domains + i);
 
    61     master->process_data = NULL;
 
    59   }
 
    62   }
 
    60 
    63 
    61   master->domain_count = 0;
 
    64   master->process_data_length = 0;
 
       
    65 }
 
    62 }
 
    66 
    63 
    67 /*****************************************************************************/
 
    64 /*****************************************************************************/
 
    68 
    65 
    69 /**
 
    66 /**
 
    80 
    77 
    81 int EtherCAT_master_open(EtherCAT_master_t *master,
 
    78 int EtherCAT_master_open(EtherCAT_master_t *master,
 
    82                          EtherCAT_device_t *device)
 
    79                          EtherCAT_device_t *device)
 
    83 {
 
    80 {
 
    84   if (!master || !device) {
 
    81   if (!master || !device) {
 
    85     printk(KERN_ERR "EtherCAT: Illegal parameters"
 
    82     printk(KERN_ERR "EtherCAT: Illegal parameters for master_open()!\n");
 
    86            " for master_open()!\n");
 
       
    87     return -1;
 
    83     return -1;
 
    88   }
 
    84   }
 
    89 
    85 
    90   if (master->dev) {
 
    86   if (master->dev) {
 
    91     printk(KERN_ERR "EtherCAT: Master already"
 
    87     printk(KERN_ERR "EtherCAT: Master already has a device.\n");
 
    92            " has a device.\n");
 
       
    93     return -1;
 
    88     return -1;
 
    94   }
 
    89   }
 
    95 
    90 
    96   if (EtherCAT_device_open(device) < 0) {
 
    91   if (EtherCAT_device_open(device) < 0) {
 
    97     printk(KERN_ERR "EtherCAT: Could not open device %X!\n",
 
    92     printk(KERN_ERR "EtherCAT: Could not open device %X!\n",
 
   195 
   190 
   196   length = cmd->data_length + 12;
 
   191   length = cmd->data_length + 12;
 
   197   framelength = length + 2;
 
   192   framelength = length + 2;
 
   198 
   193 
   199   if (unlikely(framelength > ECAT_FRAME_BUFFER_SIZE)) {
 
   194   if (unlikely(framelength > ECAT_FRAME_BUFFER_SIZE)) {
 
   200     printk(KERN_ERR "EtherCAT: Frame too long (%i)!\n",
 
   195     printk(KERN_ERR "EtherCAT: Frame too long (%i)!\n", framelength);
 
   201            framelength);
 
       
   202     return -1;
 
   196     return -1;
 
   203   }
 
   197   }
 
   204 
   198 
   205   if (framelength < 46) framelength = 46;
 
   199   if (framelength < 46) framelength = 46;
 
   206 
   200 
   254 
   248 
   255   if (unlikely(master->debug_level > 0)) {
 
   249   if (unlikely(master->debug_level > 0)) {
 
   256     printk(KERN_DEBUG "device send...\n");
 
   250     printk(KERN_DEBUG "device send...\n");
 
   257   }
 
   251   }
 
   258 
   252 
       
   253   // Zeit nehmen
 
       
   254   rdtscl(master->tx_time);
 
       
   255 
   259   // Send frame
 
   256   // Send frame
 
   260   if (unlikely(EtherCAT_device_send(master->dev,
 
   257   if (unlikely(EtherCAT_device_send(master->dev,
 
   261                                     master->tx_data,
 
   258                                     master->tx_data,
 
   262                                     framelength) != 0)) {
 
   259                                     framelength) != 0)) {
 
   263     printk(KERN_ERR "EtherCAT: Could not send!\n");
 
   260     printk(KERN_ERR "EtherCAT: Could not send!\n");
 
   295     return -1;
 
   292     return -1;
 
   296 
   293 
   297   master->rx_data_length = (unsigned int) ret;
 
   294   master->rx_data_length = (unsigned int) ret;
 
   298 
   295 
   299   if (unlikely(master->rx_data_length < 2)) {
 
   296   if (unlikely(master->rx_data_length < 2)) {
 
   300     printk(KERN_ERR "EtherCAT: Received frame with"
 
   297     printk(KERN_ERR "EtherCAT: Received frame with incomplete"
 
   301            " incomplete EtherCAT header!\n");
 
   298            " EtherCAT header!\n");
 
   302     output_debug_data(master);
 
   299     output_debug_data(master);
 
   303     return -1;
 
   300     return -1;
 
   304   }
 
   301   }
 
   305 
   302 
   306   // Länge des gesamten Frames prüfen
 
   303   // Länge des gesamten Frames prüfen
 
   307   length = ((master->rx_data[1] & 0x07) << 8)
 
   304   length = ((master->rx_data[1] & 0x07) << 8)
 
   308     | (master->rx_data[0] & 0xFF);
 
   305     | (master->rx_data[0] & 0xFF);
 
   309 
   306 
   310   if (unlikely(length > master->rx_data_length)) {
 
   307   if (unlikely(length > master->rx_data_length)) {
 
   311     printk(KERN_ERR "EtherCAT: Received corrupted"
 
   308     printk(KERN_ERR "EtherCAT: Received corrupted frame (length does"
 
   312            " frame (length does not match)!\n");
 
   309            " not match)!\n");
 
   313     output_debug_data(master);
 
   310     output_debug_data(master);
 
   314     return -1;
 
   311     return -1;
 
   315   }
 
   312   }
 
   316 
   313 
   317   command_type = master->rx_data[2];
 
   314   command_type = master->rx_data[2];
 
   335 
   332 
   336     // Empfangene Daten in Kommandodatenspeicher kopieren
 
   333     // Empfangene Daten in Kommandodatenspeicher kopieren
 
   337     memcpy(cmd->data, master->rx_data + 2 + 10, length);
 
   334     memcpy(cmd->data, master->rx_data + 2 + 10, length);
 
   338 
   335 
   339     // Working-Counter setzen
 
   336     // Working-Counter setzen
 
   340     cmd->working_counter = ((master->rx_data[length + 2 + 10] & 0xFF)
 
   337     cmd->working_counter
 
   341                             | ((master->rx_data[length + 2 + 11] & 0xFF) << 8));
 
   338       = ((master->rx_data[length + 2 + 10] & 0xFF)
 
       
   339          | ((master->rx_data[length + 2 + 11] & 0xFF) << 8));
 
   342   }
 
   340   }
 
   343   else
 
   341   else
 
   344   {
 
   342   {
 
   345     printk(KERN_WARNING "EtherCAT: WARNING - Send/Receive anomaly!\n");
 
   343     printk(KERN_WARNING "EtherCAT: WARNING - Send/Receive anomaly!\n");
 
   346     output_debug_data(master);
 
   344     output_debug_data(master);
 
   372                           EtherCAT_slave_t *slaves,
 
   370                           EtherCAT_slave_t *slaves,
 
   373                           unsigned int slave_count)
 
   371                           unsigned int slave_count)
 
   374 {
 
   372 {
 
   375   EtherCAT_command_t cmd;
 
   373   EtherCAT_command_t cmd;
 
   376   EtherCAT_slave_t *cur;
 
   374   EtherCAT_slave_t *cur;
 
   377   unsigned int i, j, found, length, pos;
 
   375   unsigned int i, j, found, size, offset;
 
   378   unsigned char data[2];
 
   376   unsigned char data[2];
 
       
   377   EtherCAT_domain_t *dom;
 
       
   378 
       
   379   // Clear domains
 
       
   380   for (i = 0; i < master->domain_count; i++) {
 
       
   381     printk(KERN_DEBUG "EtherCAT: Clearing domain %i!\n",
 
       
   382            master->domains[i].number);
 
       
   383     EtherCAT_domain_clear(master->domains + i);
 
       
   384   }
 
       
   385   master->domain_count = 0;
 
   379 
   386 
   380   if (unlikely(!slave_count)) {
 
   387   if (unlikely(!slave_count)) {
 
   381     printk(KERN_ERR "EtherCAT: No slaves in list!\n");
 
   388     printk(KERN_ERR "EtherCAT: No slaves in list!\n");
 
   382     return -1;
 
   389     return -1;
 
   383   }
 
   390   }
 
   392   if (unlikely(cmd.working_counter != slave_count)) {
 
   399   if (unlikely(cmd.working_counter != slave_count)) {
 
   393     printk(KERN_ERR "EtherCAT: Wrong number of slaves on bus: %i / %i\n",
 
   400     printk(KERN_ERR "EtherCAT: Wrong number of slaves on bus: %i / %i\n",
 
   394            cmd.working_counter, slave_count);
 
   401            cmd.working_counter, slave_count);
 
   395     return -1;
 
   402     return -1;
 
   396   }
 
   403   }
 
   397   else
 
   404 
   398     printk("EtherCAT: Found all %i slaves.\n", slave_count);
 
   405   printk("EtherCAT: Found all %i slaves.\n", slave_count);
 
   399 
   406 
   400   // For every slave in the list
 
   407   // For every slave in the list
 
   401   for (i = 0; i < slave_count; i++)
 
   408   for (i = 0; i < slave_count; i++)
 
   402   {
 
   409   {
 
   403     cur = &slaves[i];
 
   410     cur = &slaves[i];
 
   404 
   411 
   405     if (unlikely(!cur->desc)) {
 
   412     if (unlikely(!cur->desc)) {
 
   406       printk(KERN_ERR "EtherCAT: Slave %i has"
 
   413       printk(KERN_ERR "EtherCAT: Slave %i has no description.\n", i);
 
   407              " no description.\n", i);
 
       
   408       return -1;
 
   414       return -1;
 
   409     }
 
   415     }
 
   410 
   416 
   411     // Set ring position
 
   417     // Set ring position
 
   412     cur->ring_position = -i;
 
   418     cur->ring_position = -i;
 
   441              " while reading base data!\n", i);
 
   447              " while reading base data!\n", i);
 
   442       return -1;
 
   448       return -1;
 
   443     }
 
   449     }
 
   444 
   450 
   445     // Get base data
 
   451     // Get base data
 
       
   452 
   446     cur->type = cmd.data[0];
 
   453     cur->type = cmd.data[0];
 
   447     cur->revision = cmd.data[1];
 
   454     cur->revision = cmd.data[1];
 
   448     cur->build = cmd.data[2] | (cmd.data[3] << 8);
 
   455     cur->build = cmd.data[2] | (cmd.data[3] << 8);
 
   449 
   456 
   450     // Read identification from "Slave Information Interface" (SII)
 
   457     // Read identification from "Slave Information Interface" (SII)
 
   513       printk(KERN_ERR "EtherCAT: Unknown slave device"
 
   520       printk(KERN_ERR "EtherCAT: Unknown slave device"
 
   514              " (vendor %X, code %X) at position %i.\n",
 
   521              " (vendor %X, code %X) at position %i.\n",
 
   515              cur->vendor_id, cur->product_code, i);
 
   522              cur->vendor_id, cur->product_code, i);
 
   516       return -1;
 
   523       return -1;
 
   517     }
 
   524     }
 
   518   }
 
   525 
   519 
   526     // Check, if process data domain already exists...
 
   520   length = 0;
 
   527     found = 0;
 
   521   for (i = 0; i < slave_count; i++)
 
   528     for (j = 0; j < master->domain_count; j++) {
 
   522   {
 
   529       if (cur->domain == master->domains[j].number) {
 
   523     length += slaves[i].desc->data_length;
 
   530         found = 1;
 
   524   }
 
   531       }
 
   525 
   532     }
 
   526   if (unlikely((master->process_data = (unsigned char *)
 
   533 
   527                 kmalloc(sizeof(unsigned char)
 
   534     // Create process data domain
 
   528                         * length, GFP_KERNEL)) == NULL)) {
 
   535     if (!found) {
 
   529     printk(KERN_ERR "EtherCAT: Could not allocate %i"
 
   536       if (master->domain_count + 1 >= ECAT_MAX_DOMAINS) {
 
   530            " bytes for process data.\n", length);
 
   537         printk(KERN_ERR "EtherCAT: Too many domains!\n");
 
   531     return -1;
 
   538         return -1;
 
   532   }
 
   539       }
 
   533 
   540 
   534   master->process_data_length = length;
 
   541       EtherCAT_domain_init(&master->domains[master->domain_count]);
 
   535   memset(master->process_data, 0x00, length);
 
   542       master->domains[master->domain_count].number = cur->domain;
 
   536 
   543       master->domain_count++;
 
   537   pos = 0;
 
   544     }
 
   538   for (i = 0; i < slave_count; i++)
 
   545   }
 
   539   {
 
   546 
   540     slaves[i].process_data = master->process_data + pos;
 
   547   // Calculate domain sizes
 
   541     slaves[i].logical_address0 = pos;
 
   548   offset = 0;
 
   542 
   549   for (i = 0; i < master->domain_count; i++)
 
   543     printk(KERN_DEBUG "EtherCAT: Slave %i -"
 
   550   {
 
   544            " Address 0x%X, \"%s %s\", s/n %u\n",
 
   551     dom = master->domains + i;
 
   545            i, pos, slaves[i].desc->vendor_name,
 
   552 
   546            slaves[i].desc->product_name,
 
   553     dom->logical_offset = offset;
 
   547            slaves[i].serial_number);
 
   554 
   548 
   555     // For every slave in the list
 
   549     pos += slaves[i].desc->data_length;
 
   556     size = 0;
 
   550   }
 
   557     for (j = 0; j < slave_count; j++) {
 
   551 
   558       if (slaves[j].domain == dom->number) {
 
   552   master->slaves = slaves;
 
   559         size += slaves[j].desc->process_data_size;
 
   553   master->slave_count = slave_count;
 
   560       }
 
       
   561     }
 
       
   562 
       
   563     if (size > ECAT_FRAME_BUFFER_SIZE - 14) {
 
       
   564       printk(KERN_ERR "EtherCAT: Oversized domain %i: %i / %i Bytes!\n",
 
       
   565              dom->number, size, ECAT_FRAME_BUFFER_SIZE - 14);
 
       
   566       return -1;
 
       
   567     }
 
       
   568 
       
   569     if (!(dom->data = (unsigned char *) kmalloc(sizeof(unsigned char)
 
       
   570                                                * size, GFP_KERNEL))) {
 
       
   571       printk(KERN_ERR "EtherCAT: Could not allocate"
 
       
   572              " %i bytes of domain data.\n", size);
 
       
   573       return -1;
 
       
   574     }
 
       
   575 
       
   576     dom->data_size = size;
 
       
   577     memset(dom->data, 0x00, size);
 
       
   578 
       
   579     printk(KERN_INFO "EtherCAT: Domain %i: %i Bytes of process data.\n",
 
       
   580            dom->number, size);
 
       
   581 
       
   582     // Set logical addresses and data pointers of domain slaves
 
       
   583     size = 0;
 
       
   584     for (j = 0; j < slave_count; j++) {
 
       
   585       if (slaves[j].domain == dom->number) {
 
       
   586         slaves[j].process_data = dom->data + size;
 
       
   587         slaves[j].logical_address = dom->logical_offset + size;
 
       
   588         size += slaves[j].desc->process_data_size;
 
       
   589       }
 
       
   590     }
 
       
   591 
       
   592     offset += size;
 
       
   593   }
 
   554 
   594 
   555   return 0;
 
   595   return 0;
 
   556 }
 
       
   557 
       
   558 /*****************************************************************************/
 
       
   559 
       
   560 /**
 
       
   561    Entfernt den Zeiger auf das Slave-Array.
 
       
   562 
       
   563    @param master EtherCAT-Master
 
       
   564 */
 
       
   565 
       
   566 void EtherCAT_clear_slaves(EtherCAT_master_t *master)
 
       
   567 {
 
       
   568   master->slaves = NULL;
 
       
   569   master->slave_count = 0;
 
       
   570 }
 
   596 }
 
   571 
   597 
   572 /*****************************************************************************/
 
   598 /*****************************************************************************/
 
   573 
   599 
   574 /**
 
   600 /**
 
   603   data[5] = 0x00;
 
   629   data[5] = 0x00;
 
   604 
   630 
   605   EtherCAT_command_write(&cmd, node_address, 0x502, 6, data);
 
   631   EtherCAT_command_write(&cmd, node_address, 0x502, 6, data);
 
   606 
   632 
   607   if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0))
 
   633   if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0))
 
   608     return -3;
 
   634     return -1;
 
   609 
   635 
   610   if (unlikely(cmd.working_counter != 1)) {
 
   636   if (unlikely(cmd.working_counter != 1)) {
 
   611     printk(KERN_ERR "EtherCAT: SII-read - Slave"
 
   637     printk(KERN_ERR "EtherCAT: SII-read - Slave %04X did not respond!\n",
 
   612            " %04X did not respond!\n", node_address);
 
   638            node_address);
 
   613     return -4;
 
   639     return -1;
 
   614   }
 
   640   }
 
   615 
   641 
   616   // Der Slave legt die Informationen des Slave-Information-Interface
 
   642   // Der Slave legt die Informationen des Slave-Information-Interface
 
   617   // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange
 
   643   // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange
 
   618   // den Status auslesen, bis das Bit weg ist.
 
   644   // den Status auslesen, bis das Bit weg ist.
 
   623     udelay(10);
 
   649     udelay(10);
 
   624 
   650 
   625     EtherCAT_command_read(&cmd, node_address, 0x502, 10);
 
   651     EtherCAT_command_read(&cmd, node_address, 0x502, 10);
 
   626 
   652 
   627     if (unlikely(EtherCAT_simple_send_receive(master, &cmd) != 0))
 
   653     if (unlikely(EtherCAT_simple_send_receive(master, &cmd) != 0))
 
   628       return -3;
 
   654       return -1;
 
   629 
   655 
   630     if (unlikely(cmd.working_counter != 1)) {
 
   656     if (unlikely(cmd.working_counter != 1)) {
 
   631       printk(KERN_ERR "EtherCAT: SII-read status -"
 
   657       printk(KERN_ERR "EtherCAT: SII-read status -"
 
   632              " Slave %04X did not respond!\n", node_address);
 
   658              " Slave %04X did not respond!\n", node_address);
 
   633       return -4;
 
   659       return -1;
 
   634     }
 
   660     }
 
   635 
   661 
   636     if (likely((cmd.data[1] & 0x81) == 0)) {
 
   662     if (likely((cmd.data[1] & 0x81) == 0)) {
 
   637       memcpy(target, cmd.data + 6, 4);
 
   663       memcpy(target, cmd.data + 6, 4);
 
   638       break;
 
   664       break;
 
   640 
   666 
   641     tries_left--;
 
   667     tries_left--;
 
   642   }
 
   668   }
 
   643 
   669 
   644   if (unlikely(!tries_left)) {
 
   670   if (unlikely(!tries_left)) {
 
   645     printk(KERN_WARNING "EtherCAT: SSI-read."
 
   671     printk(KERN_WARNING "EtherCAT: SSI-read. Slave %04X timed out!\n",
 
   646            " Slave %04X timed out!\n", node_address);
 
   672            node_address);
 
   647     return -1;
 
   673     return -1;
 
   648   }
 
   674   }
 
   649 
   675 
   650   return 0;
 
   676   return 0;
 
   651 }
 
   677 }
 
   782 
   808 
   783   if (unlikely(cmd.working_counter != 1)) {
 
   809   if (unlikely(cmd.working_counter != 1)) {
 
   784     printk(KERN_ERR "EtherCAT: Resetting FMMUs -"
 
   810     printk(KERN_ERR "EtherCAT: Resetting FMMUs -"
 
   785            " Slave %04X did not respond!\n",
 
   811            " Slave %04X did not respond!\n",
 
   786            slave->station_address);
 
   812            slave->station_address);
 
   787     return -2;
 
   813     return -1;
 
   788   }
 
   814   }
 
   789 
   815 
   790   // Resetting Sync Manager channels
 
   816   // Resetting Sync Manager channels
 
   791 
   817 
   792   if (desc->type != ECAT_ST_SIMPLE_NOSYNC)
 
   818   if (desc->type != ECAT_ST_SIMPLE_NOSYNC)
 
   801 
   827 
   802     if (unlikely(cmd.working_counter != 1)) {
 
   828     if (unlikely(cmd.working_counter != 1)) {
 
   803       printk(KERN_ERR "EtherCAT: Resetting SMs -"
 
   829       printk(KERN_ERR "EtherCAT: Resetting SMs -"
 
   804              " Slave %04X did not respond!\n",
 
   830              " Slave %04X did not respond!\n",
 
   805              slave->station_address);
 
   831              slave->station_address);
 
   806       return -2;
 
   832       return -1;
 
   807     }
 
   833     }
 
   808   }
 
   834   }
 
   809 
   835 
   810   // Init Mailbox communication
 
   836   // Init Mailbox communication
 
   811 
   837 
   821 
   847 
   822       if (unlikely(cmd.working_counter != 1)) {
 
   848       if (unlikely(cmd.working_counter != 1)) {
 
   823         printk(KERN_ERR "EtherCAT: Setting SM0 -"
 
   849         printk(KERN_ERR "EtherCAT: Setting SM0 -"
 
   824                " Slave %04X did not respond!\n",
 
   850                " Slave %04X did not respond!\n",
 
   825                slave->station_address);
 
   851                slave->station_address);
 
   826         return -3;
 
   852         return -1;
 
   827       }
 
   853       }
 
   828     }
 
   854     }
 
   829 
   855 
   830     if (desc->sm1)
 
   856     if (desc->sm1)
 
   831     {
 
   857     {
 
   837 
   863 
   838       if (unlikely(cmd.working_counter != 1)) {
 
   864       if (unlikely(cmd.working_counter != 1)) {
 
   839         printk(KERN_ERR "EtherCAT: Setting SM1 -"
 
   865         printk(KERN_ERR "EtherCAT: Setting SM1 -"
 
   840                " Slave %04X did not respond!\n",
 
   866                " Slave %04X did not respond!\n",
 
   841                slave->station_address);
 
   867                slave->station_address);
 
   842         return -2;
 
   868         return -1;
 
   843       }
 
   869       }
 
   844     }
 
   870     }
 
   845   }
 
   871   }
 
   846 
   872 
   847   // Change state to PREOP
 
   873   // Change state to PREOP
 
   848 
   874 
   849   if (unlikely(EtherCAT_state_change(master, slave,
 
   875   if (unlikely(EtherCAT_state_change(master, slave,
 
   850                                      ECAT_STATE_PREOP) != 0))
 
   876                                      ECAT_STATE_PREOP) != 0))
 
   851     return -5;
 
   877     return -1;
 
   852 
   878 
   853   // Set FMMU's
 
   879   // Set FMMU's
 
   854 
   880 
   855   if (desc->fmmu0)
 
   881   if (desc->fmmu0)
 
   856   {
 
   882   {
 
       
   883     if (unlikely(!slave->process_data)) {
 
       
   884       printk(KERN_ERR "EtherCAT: Warning - Slave %04X is not assigned to any"
 
       
   885              " process data object!\n", slave->station_address);
 
       
   886       return -1;
 
       
   887     }
 
       
   888 
   857     memcpy(fmmu, desc->fmmu0, 16);
 
   889     memcpy(fmmu, desc->fmmu0, 16);
 
   858 
   890 
   859     fmmu[0] = slave->logical_address0 & 0x000000FF;
 
   891     fmmu[0] = slave->logical_address & 0x000000FF;
 
   860     fmmu[1] = (slave->logical_address0 & 0x0000FF00) >> 8;
 
   892     fmmu[1] = (slave->logical_address & 0x0000FF00) >> 8;
 
   861     fmmu[2] = (slave->logical_address0 & 0x00FF0000) >> 16;
 
   893     fmmu[2] = (slave->logical_address & 0x00FF0000) >> 16;
 
   862     fmmu[3] = (slave->logical_address0 & 0xFF000000) >> 24;
 
   894     fmmu[3] = (slave->logical_address & 0xFF000000) >> 24;
 
   863 
   895 
   864     EtherCAT_command_write(&cmd, slave->station_address,
 
   896     EtherCAT_command_write(&cmd, slave->station_address,
 
   865                            0x0600, 16, fmmu);
 
   897                            0x0600, 16, fmmu);
 
   866 
   898 
   867     if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0))
 
   899     if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0))
 
   869 
   901 
   870     if (unlikely(cmd.working_counter != 1)) {
 
   902     if (unlikely(cmd.working_counter != 1)) {
 
   871       printk(KERN_ERR "EtherCAT: Setting FMMU0 -"
 
   903       printk(KERN_ERR "EtherCAT: Setting FMMU0 -"
 
   872              " Slave %04X did not respond!\n",
 
   904              " Slave %04X did not respond!\n",
 
   873              slave->station_address);
 
   905              slave->station_address);
 
   874       return -2;
 
   906       return -1;
 
   875     }
 
   907     }
 
   876   }
 
   908   }
 
   877 
   909 
   878   // Set Sync Managers
 
   910   // Set Sync Managers
 
   879 
   911 
   889 
   921 
   890       if (unlikely(cmd.working_counter != 1)) {
 
   922       if (unlikely(cmd.working_counter != 1)) {
 
   891         printk(KERN_ERR "EtherCAT: Setting SM0 -"
 
   923         printk(KERN_ERR "EtherCAT: Setting SM0 -"
 
   892                " Slave %04X did not respond!\n",
 
   924                " Slave %04X did not respond!\n",
 
   893                slave->station_address);
 
   925                slave->station_address);
 
   894         return -3;
 
   926         return -1;
 
   895       }
 
   927       }
 
   896     }
 
   928     }
 
   897 
   929 
   898     if (desc->sm1)
 
   930     if (desc->sm1)
 
   899     {
 
   931     {
 
   905 
   937 
   906       if (unlikely(cmd.working_counter != 1)) {
 
   938       if (unlikely(cmd.working_counter != 1)) {
 
   907         printk(KERN_ERR "EtherCAT: Setting SM1 -"
 
   939         printk(KERN_ERR "EtherCAT: Setting SM1 -"
 
   908                " Slave %04X did not respond!\n",
 
   940                " Slave %04X did not respond!\n",
 
   909                slave->station_address);
 
   941                slave->station_address);
 
   910         return -3;
 
   942         return -1;
 
   911       }
 
   943       }
 
   912     }
 
   944     }
 
   913   }
 
   945   }
 
   914 
   946 
   915   if (desc->sm2)
 
   947   if (desc->sm2)
 
   922 
   954 
   923     if (unlikely(cmd.working_counter != 1)) {
 
   955     if (unlikely(cmd.working_counter != 1)) {
 
   924       printk(KERN_ERR "EtherCAT: Setting SM2 -"
 
   956       printk(KERN_ERR "EtherCAT: Setting SM2 -"
 
   925              " Slave %04X did not respond!\n",
 
   957              " Slave %04X did not respond!\n",
 
   926              slave->station_address);
 
   958              slave->station_address);
 
   927       return -3;
 
   959       return -1;
 
   928     }
 
   960     }
 
   929   }
 
   961   }
 
   930 
   962 
   931   if (desc->sm3)
 
   963   if (desc->sm3)
 
   932   {
 
   964   {
 
   938 
   970 
   939     if (unlikely(cmd.working_counter != 1)) {
 
   971     if (unlikely(cmd.working_counter != 1)) {
 
   940       printk(KERN_ERR "EtherCAT: Setting SM3 -"
 
   972       printk(KERN_ERR "EtherCAT: Setting SM3 -"
 
   941              " Slave %04X did not respond!\n",
 
   973              " Slave %04X did not respond!\n",
 
   942              slave->station_address);
 
   974              slave->station_address);
 
   943       return -3;
 
   975       return -1;
 
   944     }
 
   976     }
 
   945   }
 
   977   }
 
   946 
   978 
   947   // Change state to SAVEOP
 
   979   // Change state to SAVEOP
 
   948   if (unlikely(EtherCAT_state_change(master, slave,
 
   980   if (unlikely(EtherCAT_state_change(master, slave,
 
   949                                      ECAT_STATE_SAVEOP) != 0))
 
   981                                      ECAT_STATE_SAVEOP) != 0))
 
   950     return -12;
 
   982     return -1;
 
   951 
   983 
   952   // Change state to OP
 
   984   // Change state to OP
 
   953   if (unlikely(EtherCAT_state_change(master, slave,
 
   985   if (unlikely(EtherCAT_state_change(master, slave,
 
   954                                      ECAT_STATE_OP) != 0))
 
   986                                      ECAT_STATE_OP) != 0))
 
   955     return -13;
 
   987     return -1;
 
   956 
   988 
   957   return 0;
 
   989   return 0;
 
   958 }
 
   990 }
 
   959 
   991 
   960 /*****************************************************************************/
 
   992 /*****************************************************************************/
 
   979 }
 
  1011 }
 
   980 
  1012 
   981 /*****************************************************************************/
 
  1013 /*****************************************************************************/
 
   982 
  1014 
   983 /**
 
  1015 /**
 
   984    Aktiviert alle Slaves.
 
  1016    Sendet und empfängt Prozessdaten der angegebenen Domäne
 
   985 
       
   986    @see EtherCAT_activate_slave
 
       
   987 
  1017 
   988    @param master EtherCAT-Master
 
  1018    @param master EtherCAT-Master
 
       
  1019           domain Domäne
 
   989 
  1020 
   990    @return 0 bei Erfolg, sonst < 0
 
  1021    @return 0 bei Erfolg, sonst < 0
 
   991 */
 
  1022 */
 
   992 
  1023 
   993 int EtherCAT_activate_all_slaves(EtherCAT_master_t *master)
 
  1024 int EtherCAT_process_data_cycle(EtherCAT_master_t *master,
 
   994 {
 
  1025                                 unsigned int domain)
 
   995   unsigned int i;
 
  1026 {
 
   996 
  1027   unsigned int i, tries;
 
   997   for (i = 0; i < master->slave_count; i++)
 
  1028   EtherCAT_domain_t *dom = NULL;
 
   998   {
 
  1029 
   999     if (unlikely(EtherCAT_activate_slave(master,
 
  1030   for (i = 0; i < master->domain_count; i++) {
 
  1000                                          &master->slaves[i]) < 0))
 
  1031     if (master->domains[i].number == domain) {
 
  1001       return -1;
 
  1032       dom = master->domains + i;
 
  1002   }
 
  1033       break;
 
  1003 
  1034     }
 
  1004   return 0;
 
  1035   }
 
  1005 }
 
  1036 
  1006 
  1037   if (unlikely(!dom)) {
 
  1007 /*****************************************************************************/
 
  1038     printk(KERN_ERR "EtherCAT: No such domain: %i!\n", domain);
 
  1008 
  1039     return -1;
 
  1009 /**
 
  1040   }
 
  1010    Deaktiviert alle Slaves.
 
  1041 
  1011 
  1042   EtherCAT_command_logical_read_write(&dom->command,
 
  1012    @see EtherCAT_deactivate_slave
 
  1043                                       dom->logical_offset, dom->data_size,
 
  1013 
  1044                                       dom->data);
 
  1014    @param master EtherCAT-Master
 
  1045 
  1015 
  1046   if (unlikely(EtherCAT_simple_send(master, &dom->command) < 0)) {
 
  1016    @return 0 bei Erfolg, sonst < 0
 
  1047     printk(KERN_ERR "EtherCAT: Could not send process data command!\n");
 
  1017 */
 
  1048     return -1;
 
  1018 
  1049   }
 
  1019 int EtherCAT_deactivate_all_slaves(EtherCAT_master_t *master)
 
  1050 
  1020 {
 
  1051   udelay(3);
 
  1021   unsigned int i;
 
  1052 
  1022   int ret = 0;
 
  1053 #if 1
 
  1023 
  1054   // Warten
 
  1024   for (i = 0; i < master->slave_count; i++)
 
  1055   tries = 0;
 
  1025   {
 
       
  1026     if (unlikely(EtherCAT_deactivate_slave(master,
 
       
  1027                                            &master->slaves[i]) < 0))
 
       
  1028       ret = -1;
 
       
  1029   }
 
       
  1030 
       
  1031   return ret;
 
       
  1032 }
 
       
  1033 
       
  1034 /*****************************************************************************/
 
       
  1035 
       
  1036 /**
 
       
  1037    Sendet alle Prozessdaten an die Slaves.
 
       
  1038 
       
  1039    Erstellt ein "logical read write"-Kommando mit den
 
       
  1040    Prozessdaten des Masters und sendet es an den Bus.
 
       
  1041 
       
  1042    @param master EtherCAT-Master
 
       
  1043 
       
  1044    @return 0 bei Erfolg, sonst < 0
 
       
  1045 */
 
       
  1046 
       
  1047 int EtherCAT_write_process_data(EtherCAT_master_t *master)
 
       
  1048 {
 
       
  1049   EtherCAT_command_logical_read_write(&master->process_data_command,
 
       
  1050                                       0, master->process_data_length,
 
       
  1051                                       master->process_data);
 
       
  1052 
       
  1053   if (unlikely(EtherCAT_simple_send(master,
 
       
  1054                                     &master->process_data_command) < 0))
 
       
  1055   {
 
       
  1056     printk(KERN_ERR "EtherCAT: Could not send"
 
       
  1057            " process data command!\n");
 
       
  1058     return -1;
 
       
  1059   }
 
       
  1060 
       
  1061   return 0;
 
       
  1062 }
 
       
  1063 
       
  1064 /*****************************************************************************/
 
       
  1065 
       
  1066 /**
 
       
  1067    Empfängt alle Prozessdaten von den Slaves.
 
       
  1068 
       
  1069    Empfängt ein zuvor gesendetes "logical read write"-Kommando
 
       
  1070    und kopiert die empfangenen daten in den Prozessdatenspeicher
 
       
  1071    des Masters.
 
       
  1072 
       
  1073    @param master EtherCAT-Master
 
       
  1074 
       
  1075    @return 0 bei Erfolg, sonst < 0
 
       
  1076 */
 
       
  1077 
       
  1078 int EtherCAT_read_process_data(EtherCAT_master_t *master)
 
       
  1079 {
 
       
  1080   unsigned int tries_left;
 
       
  1081 
       
  1082   EtherCAT_device_call_isr(master->dev);
 
  1056   EtherCAT_device_call_isr(master->dev);
 
  1083 
  1057   while (unlikely(master->dev->state == ECAT_DS_SENT && tries < 100)) {
 
  1084   tries_left = 20;
 
       
  1085   while (unlikely(master->dev->state == ECAT_DS_SENT
 
       
  1086                   && tries_left))
 
       
  1087   {
 
       
  1088     udelay(1);
 
  1058     udelay(1);
 
  1089     EtherCAT_device_call_isr(master->dev);
 
  1059     EtherCAT_device_call_isr(master->dev);
 
  1090     tries_left--;
 
  1060     tries++;
 
  1091   }
 
  1061   }
 
  1092 
  1062 
  1093   if (unlikely(!tries_left))
 
  1063   rdtscl(master->rx_time);
 
  1094   {
 
  1064   master->rx_tries = tries;
 
       
  1065 
       
  1066   if (unlikely(tries == 100)) {
 
  1095     printk(KERN_ERR "EtherCAT: Timeout while receiving process data!\n");
 
  1067     printk(KERN_ERR "EtherCAT: Timeout while receiving process data!\n");
 
  1096     return -1;
 
  1068     return -1;
 
  1097   }
 
  1069   }
 
  1098 
  1070 
  1099   if (unlikely(EtherCAT_simple_receive(master,
 
  1071   if (unlikely(EtherCAT_simple_receive(master, &dom->command) < 0)) {
 
  1100                                        &master->process_data_command) < 0))
 
       
  1101   {
 
       
  1102     printk(KERN_ERR "EtherCAT: Could not receive cyclic command!\n");
 
  1072     printk(KERN_ERR "EtherCAT: Could not receive cyclic command!\n");
 
  1103     return -1;
 
  1073     return -1;
 
  1104   }
 
  1074   }
 
  1105 
  1075 
  1106   if (unlikely(master->process_data_command.state != ECAT_CS_RECEIVED))
 
  1076   if (unlikely(dom->command.state != ECAT_CS_RECEIVED)) {
 
  1107   {
 
       
  1108     printk(KERN_WARNING "EtherCAT: Process data command not received!\n");
 
  1077     printk(KERN_WARNING "EtherCAT: Process data command not received!\n");
 
  1109     return -1;
 
  1078     return -1;
 
  1110   }
 
  1079   }
 
  1111 
  1080 
  1112   // Daten von Kommando in Prozessdaten des Master kopieren
 
  1081   // Daten vom Kommando in den Prozessdatenspeicher kopieren
 
  1113   memcpy(master->process_data, master->process_data_command.data,
 
  1082   memcpy(dom->data, dom->command.data, dom->data_size);
 
  1114          master->process_data_length);
 
  1083 #endif
 
  1115 
  1084 
  1116   return 0;
 
  1085   return 0;
 
  1117 }
 
       
  1118 
       
  1119 /*****************************************************************************/
 
       
  1120 
       
  1121 /**
 
       
  1122    Verwirft das zuletzt gesendete Prozessdatenkommando.
 
       
  1123 
       
  1124    @param master EtherCAT-Master
 
       
  1125 */
 
       
  1126 
       
  1127 void EtherCAT_clear_process_data(EtherCAT_master_t *master)
 
       
  1128 {
 
       
  1129   EtherCAT_device_call_isr(master->dev);
 
       
  1130   master->dev->state = ECAT_DS_READY;
 
       
  1131 }
 
  1086 }
 
  1132 
  1087 
  1133 /*****************************************************************************/
 
  1088 /*****************************************************************************/
 
  1134 
  1089 
  1135 /**
 
  1090 /**
 
  1169 
  1124 
  1170 EXPORT_SYMBOL(EtherCAT_master_init);
 
  1125 EXPORT_SYMBOL(EtherCAT_master_init);
 
  1171 EXPORT_SYMBOL(EtherCAT_master_clear);
 
  1126 EXPORT_SYMBOL(EtherCAT_master_clear);
 
  1172 EXPORT_SYMBOL(EtherCAT_master_open);
 
  1127 EXPORT_SYMBOL(EtherCAT_master_open);
 
  1173 EXPORT_SYMBOL(EtherCAT_master_close);
 
  1128 EXPORT_SYMBOL(EtherCAT_master_close);
 
  1174 EXPORT_SYMBOL(EtherCAT_read_process_data);
 
       
  1175 EXPORT_SYMBOL(EtherCAT_write_process_data);
 
       
  1176 EXPORT_SYMBOL(EtherCAT_check_slaves);
 
  1129 EXPORT_SYMBOL(EtherCAT_check_slaves);
 
  1177 EXPORT_SYMBOL(EtherCAT_activate_all_slaves);
 
  1130 EXPORT_SYMBOL(EtherCAT_activate_slave);
 
  1178 EXPORT_SYMBOL(EtherCAT_clear_process_data);
 
  1131 EXPORT_SYMBOL(EtherCAT_deactivate_slave);
 
  1179 EXPORT_SYMBOL(EtherCAT_deactivate_all_slaves);
 
  1132 EXPORT_SYMBOL(EtherCAT_process_data_cycle);
 
  1180 
  1133 
  1181 /*****************************************************************************/
 
  1134 /*****************************************************************************/
 
       
  1135 
       
  1136 /* Emacs-Konfiguration
 
       
  1137 ;;; Local Variables: ***
 
       
  1138 ;;; c-basic-offset:2 ***
 
       
  1139 ;;; End: ***
 
       
  1140 */
etherlabmaster