Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/device.c
changeset 84 b4ae98855cea
parent 78 3d74183d6c6b
child 91 0120d6214948
equal deleted inserted replaced
83:e8b76a509bc9 84:b4ae98855cea 
    37     device->isr = NULL;
 
    37     device->isr = NULL;
 
    38     device->module = NULL;
 
    38     device->module = NULL;
 
    39     device->error_reported = 0;
 
    39     device->error_reported = 0;
 
    40 
    40 
    41     if ((device->tx_skb = dev_alloc_skb(ETH_HLEN + EC_MAX_FRAME_SIZE)) == NULL) {
 
    41     if ((device->tx_skb = dev_alloc_skb(ETH_HLEN + EC_MAX_FRAME_SIZE)) == NULL) {
 
    42         printk(KERN_ERR "EtherCAT: Error allocating device socket buffer!\n");
 
    42         EC_ERR("Error allocating device socket buffer!\n");
 
    43         return -1;
 
    43         return -1;
 
    44     }
 
    44     }
 
    45 
    45 
    46     return 0;
 
    46     return 0;
 
    47 }
 
    47 }
 
    83 int ec_device_open(ec_device_t *device /**< EtherCAT-Gerät */)
 
    83 int ec_device_open(ec_device_t *device /**< EtherCAT-Gerät */)
 
    84 {
 
    84 {
 
    85     unsigned int i;
 
    85     unsigned int i;
 
    86 
    86 
    87     if (!device) {
 
    87     if (!device) {
 
    88         printk(KERN_ERR "EtherCAT: Trying to open a NULL device!\n");
 
    88         EC_ERR("Trying to open a NULL device!\n");
 
    89         return -1;
 
    89         return -1;
 
    90     }
 
    90     }
 
    91 
    91 
    92     if (!device->dev) {
 
    92     if (!device->dev) {
 
    93         printk(KERN_ERR "EtherCAT: No net_device to open!\n");
 
    93         EC_ERR("No net_device to open!\n");
 
    94         return -1;
 
    94         return -1;
 
    95     }
 
    95     }
 
    96 
    96 
    97     if (device->open) {
 
    97     if (device->open) {
 
    98         printk(KERN_WARNING "EtherCAT: Device already opened!\n");
 
    98         EC_WARN("Device already opened!\n");
 
    99     }
 
    99     }
 
   100     else {
 
   100     else {
 
   101         // Device could have received frames before
 
   101         // Device could have received frames before
 
   102         for (i = 0; i < 4; i++) ec_device_call_isr(device);
 
   102         for (i = 0; i < 4; i++) ec_device_call_isr(device);
 
   103 
   103 
   120 */
 
   120 */
 
   121 
   121 
   122 int ec_device_close(ec_device_t *device /**< EtherCAT-Gerät */)
 
   122 int ec_device_close(ec_device_t *device /**< EtherCAT-Gerät */)
 
   123 {
 
   123 {
 
   124     if (!device->dev) {
 
   124     if (!device->dev) {
 
   125         printk(KERN_ERR "EtherCAT: No device to close!\n");
 
   125         EC_ERR("No device to close!\n");
 
   126         return -1;
 
   126         return -1;
 
   127     }
 
   127     }
 
   128 
   128 
   129     if (!device->open) {
 
   129     if (!device->open) {
 
   130         printk(KERN_WARNING "EtherCAT: Device already closed!\n");
 
   130         EC_WARN("Device already closed!\n");
 
   131     }
 
   131     }
 
   132     else {
 
   132     else {
 
   133         if (device->dev->stop(device->dev) == 0) device->open = 0;
 
   133         if (device->dev->stop(device->dev) == 0) device->open = 0;
 
   134     }
 
   134     }
 
   135 
   135 
   184 
   184 
   185     device->state = EC_DEVICE_STATE_SENT;
 
   185     device->state = EC_DEVICE_STATE_SENT;
 
   186     device->rx_data_size = 0;
 
   186     device->rx_data_size = 0;
 
   187 
   187 
   188     if (unlikely(device->master->debug_level > 1)) {
 
   188     if (unlikely(device->master->debug_level > 1)) {
 
   189         printk(KERN_DEBUG "EtherCAT: Sending frame:\n");
 
   189         EC_DBG("Sending frame:\n");
 
   190         ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
 
   190         ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
 
   191     }
 
   191     }
 
   192 
   192 
   193     // Senden einleiten
 
   193     // Senden einleiten
 
   194     rdtscl(device->tx_time); // Get CPU cycles
 
   194     rdtscl(device->tx_time); // Get CPU cycles
 
   238    Gibt alle Informationen über das Device-Objekt aus.
 
   238    Gibt alle Informationen über das Device-Objekt aus.
 
   239 */
 
   239 */
 
   240 
   240 
   241 void ec_device_print(ec_device_t *device /**< EtherCAT-Gerät */)
 
   241 void ec_device_print(ec_device_t *device /**< EtherCAT-Gerät */)
 
   242 {
 
   242 {
 
   243     printk(KERN_DEBUG "---EtherCAT device information begin---\n");
 
   243     EC_DBG("---EtherCAT device information begin---\n");
 
   244 
   244 
   245     if (device)
 
   245     if (device) {
 
   246     {
 
   246         EC_DBG("Assigned net_device: %X\n", (u32) device->dev);
 
   247         printk(KERN_DEBUG "Assigned net_device: %X\n",
 
   247         EC_DBG("Transmit socket buffer: %X\n", (u32) device->tx_skb);
 
   248                (unsigned) device->dev);
 
   248         EC_DBG("Time of last transmission: %u\n", (u32) device->tx_time);
 
   249         printk(KERN_DEBUG "Transmit socket buffer: %X\n",
 
   249         EC_DBG("Time of last receive: %u\n", (u32) device->rx_time);
 
   250                (unsigned) device->tx_skb);
 
   250         EC_DBG("Actual device state: %i\n", (u8) device->state);
 
   251         printk(KERN_DEBUG "Time of last transmission: %u\n",
 
   251         EC_DBG("Receive buffer: %X\n", (u32) device->rx_data);
 
   252                (unsigned) device->tx_time);
 
   252         EC_DBG("Receive buffer fill state: %u/%u\n",
 
   253         printk(KERN_DEBUG "Time of last receive: %u\n",
 
   253                (u32) device->rx_data_size, EC_MAX_FRAME_SIZE);
 
   254                (unsigned) device->rx_time);
 
   254     }
 
   255         printk(KERN_DEBUG "Actual device state: %i\n",
 
   255     else {
 
   256                (int) device->state);
 
   256         EC_DBG("Device is NULL!\n");
 
   257         printk(KERN_DEBUG "Receive buffer: %X\n",
 
   257     }
 
   258                (unsigned) device->rx_data);
 
   258 
   259         printk(KERN_DEBUG "Receive buffer fill state: %u/%u\n",
 
   259     EC_DBG("---EtherCAT device information end---\n");
 
   260                (unsigned) device->rx_data_size, EC_MAX_FRAME_SIZE);
 
       
   261     }
 
       
   262     else
 
       
   263     {
 
       
   264         printk(KERN_DEBUG "Device is NULL!\n");
 
       
   265     }
 
       
   266 
       
   267     printk(KERN_DEBUG "---EtherCAT device information end---\n");
 
       
   268 }
 
   260 }
 
   269 
   261 
   270 /*****************************************************************************/
 
   262 /*****************************************************************************/
 
   271 
   263 
   272 /**
 
   264 /**
 
   273    Gibt das letzte Rahmenpaar aus.
 
   265    Gibt das letzte Rahmenpaar aus.
 
   274 */
 
   266 */
 
   275 
   267 
   276 void ec_device_debug(const ec_device_t *device /**< EtherCAT-Gerät */)
 
   268 void ec_device_debug(const ec_device_t *device /**< EtherCAT-Gerät */)
 
   277 {
 
   269 {
 
   278     printk(KERN_DEBUG "EtherCAT: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
 
   270     EC_DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
 
   279     ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
 
   271     ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
 
   280     printk(KERN_DEBUG "------------------------------------------------\n");
 
   272     EC_DBG("------------------------------------------------\n");
 
   281     ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
 
   273     ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
 
   282                        device->rx_data_size);
 
   274                        device->rx_data_size);
 
   283     printk(KERN_DEBUG "EtherCAT: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
 
   275     EC_DBG("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
 
   284 }
 
   276 }
 
   285 
   277 
   286 /*****************************************************************************/
 
   278 /*****************************************************************************/
 
   287 
   279 
   288 /**
 
   280 /**
 
   293                    size_t size /**< Anzahl Bytes */
 
   285                    size_t size /**< Anzahl Bytes */
 
   294                    )
 
   286                    )
 
   295 {
 
   287 {
 
   296     size_t i;
 
   288     size_t i;
 
   297 
   289 
   298     printk(KERN_DEBUG);
 
   290     EC_DBG("");
 
   299     for (i = 0; i < size; i++) {
 
   291     for (i = 0; i < size; i++) {
 
   300         printk("%02X ", data[i]);
 
   292         printk("%02X ", data[i]);
 
   301         if ((i + 1) % 16 == 0) printk("\n" KERN_DEBUG);
 
   293         if ((i + 1) % 16 == 0) {
 
       
   294             printk("\n");
 
       
   295             EC_DBG("");
 
       
   296         }
 
   302     }
 
   297     }
 
   303     printk("\n");
 
   298     printk("\n");
 
   304 }
 
   299 }
 
   305 
   300 
   306 /*****************************************************************************/
 
   301 /*****************************************************************************/
 
   314                         size_t size /** Anzahl Bytes */
 
   309                         size_t size /** Anzahl Bytes */
 
   315                         )
 
   310                         )
 
   316 {
 
   311 {
 
   317     size_t i;
 
   312     size_t i;
 
   318 
   313 
   319     printk(KERN_DEBUG);
 
   314     EC_DBG("");
 
   320     for (i = 0; i < size; i++) {
 
   315     for (i = 0; i < size; i++) {
 
   321         if (d1[i] == d2[i]) printk(".. ");
 
   316         if (d1[i] == d2[i]) printk(".. ");
 
   322         else printk("%02X ", d2[i]);
 
   317         else printk("%02X ", d2[i]);
 
   323         if ((i + 1) % 16 == 0) printk("\n" KERN_DEBUG);
 
   318         if ((i + 1) % 16 == 0) {
 
       
   319             printk("\n");
 
       
   320             EC_DBG("");
 
       
   321         }
 
   324     }
 
   322     }
 
   325     printk("\n");
 
   323     printk("\n");
 
   326 }
 
   324 }
 
   327 
   325 
   328 /******************************************************************************
 
   326 /******************************************************************************
 
   363     memcpy(device->rx_data, data, size);
 
   361     memcpy(device->rx_data, data, size);
 
   364     device->rx_data_size = size;
 
   362     device->rx_data_size = size;
 
   365     device->state = EC_DEVICE_STATE_RECEIVED;
 
   363     device->state = EC_DEVICE_STATE_RECEIVED;
 
   366 
   364 
   367     if (unlikely(device->master->debug_level > 1)) {
 
   365     if (unlikely(device->master->debug_level > 1)) {
 
   368         printk(KERN_DEBUG "EtherCAT: Received frame:\n");
 
   366         EC_DBG("Received frame:\n");
 
   369         ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
 
   367         ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
 
   370                            device->rx_data_size);
 
   368                            device->rx_data_size);
 
   371     }
 
   369     }
 
   372 }
 
   370 }
 
   373 
   371
etherlabmaster