master/module.c
changeset 55 059a9e712aa7
parent 54 7506e67dd122
child 56 36d1fa37f5e1
equal deleted inserted replaced
54:7506e67dd122 55:059a9e712aa7
   166                                    irqreturn_t (*isr)(int, void *,
   166                                    irqreturn_t (*isr)(int, void *,
   167                                                       struct pt_regs *),
   167                                                       struct pt_regs *),
   168                                    struct module *module)
   168                                    struct module *module)
   169 {
   169 {
   170   ec_device_t *ecd;
   170   ec_device_t *ecd;
       
   171   ec_master_t *master;
   171 
   172 
   172   if (master_index >= ec_master_count) {
   173   if (master_index >= ec_master_count) {
   173     printk(KERN_ERR "EtherCAT: Master %i does not exist!\n", master_index);
   174     printk(KERN_ERR "EtherCAT: Master %i does not exist!\n", master_index);
   174     return NULL;
   175     return NULL;
   175   }
   176   }
   177   if (!dev) {
   178   if (!dev) {
   178     printk("EtherCAT: Device is NULL!\n");
   179     printk("EtherCAT: Device is NULL!\n");
   179     return NULL;
   180     return NULL;
   180   }
   181   }
   181 
   182 
   182   if (ec_masters[master_index].device_registered) {
   183   master = ec_masters + master_index;
       
   184 
       
   185   if (master->device_registered) {
   183     printk(KERN_ERR "EtherCAT: Master %i already has a device!\n",
   186     printk(KERN_ERR "EtherCAT: Master %i already has a device!\n",
   184            master_index);
   187            master_index);
   185     return NULL;
   188     return NULL;
   186   }
   189   }
   187 
   190 
   188   ecd = &ec_masters[master_index].device;
   191   ecd = &master->device;
   189 
   192 
   190   if (ec_device_init(ecd) < 0) {
   193   if (ec_device_init(ecd) < 0) {
   191     return NULL;
   194     return NULL;
   192   }
   195   }
   193 
   196 
   195   ecd->tx_skb->dev = dev;
   198   ecd->tx_skb->dev = dev;
   196   ecd->rx_skb->dev = dev;
   199   ecd->rx_skb->dev = dev;
   197   ecd->isr = isr;
   200   ecd->isr = isr;
   198   ecd->module = module;
   201   ecd->module = module;
   199 
   202 
       
   203   master->device_registered = 1;
       
   204 
   200   return ecd;
   205   return ecd;
   201 }
   206 }
   202 
   207 
   203 /*****************************************************************************/
   208 /*****************************************************************************/
   204 
   209 
   207 
   212 
   208    @param master Der EtherCAT-Master
   213    @param master Der EtherCAT-Master
   209    @param device Das EtherCAT-Geraet
   214    @param device Das EtherCAT-Geraet
   210 */
   215 */
   211 
   216 
   212 void EtherCAT_dev_unregister(unsigned int master_index)
   217 void EtherCAT_dev_unregister(unsigned int master_index, ec_device_t *ecd)
   213 {
   218 {
       
   219   ec_master_t *master;
       
   220 
   214   if (master_index >= ec_master_count) {
   221   if (master_index >= ec_master_count) {
   215     printk(KERN_WARNING "EtherCAT: Master %i does not exist!\n", master_index);
   222     printk(KERN_WARNING "EtherCAT: Master %i does not exist!\n", master_index);
   216     return;
   223     return;
   217   }
   224   }
   218 
   225 
   219   ec_masters[master_index].device_registered = 0;
   226   master = ec_masters + master_index;
   220   ec_device_clear(&ec_masters[master_index].device);
   227 
       
   228   if (!master->device_registered || &master->device != ecd) {
       
   229     printk(KERN_ERR "EtherCAT: Unable to unregister device!\n");
       
   230     return;
       
   231   }
       
   232 
       
   233   master->device_registered = 0;
       
   234   ec_device_clear(ecd);
   221 }
   235 }
   222 
   236 
   223 /******************************************************************************
   237 /******************************************************************************
   224  *
   238  *
   225  * Echtzeitschnittstelle
   239  * Echtzeitschnittstelle
   233 
   247 
   234    @param index Index des gewuenschten Masters
   248    @param index Index des gewuenschten Masters
   235    @returns Zeiger auf EtherCAT-Master oder NULL, wenn Parameter ungueltig.
   249    @returns Zeiger auf EtherCAT-Master oder NULL, wenn Parameter ungueltig.
   236 */
   250 */
   237 
   251 
   238 ec_master_t *EtherCAT_rt_request_master(int index)
   252 ec_master_t *EtherCAT_rt_request_master(unsigned int index)
   239 {
   253 {
   240   ec_master_t *master;
   254   ec_master_t *master;
   241 
   255 
   242   if (index < 0 || index >= ec_master_count) {
   256   if (index < 0 || index >= ec_master_count) {
   243     printk(KERN_ERR "EtherCAT: Master %i does not exist!\n", index);
   257     printk(KERN_ERR "EtherCAT: Master %i does not exist!\n", index);
   332 EXPORT_SYMBOL(EtherCAT_dev_unregister);
   346 EXPORT_SYMBOL(EtherCAT_dev_unregister);
   333 EXPORT_SYMBOL(EtherCAT_rt_request_master);
   347 EXPORT_SYMBOL(EtherCAT_rt_request_master);
   334 EXPORT_SYMBOL(EtherCAT_rt_release_master);
   348 EXPORT_SYMBOL(EtherCAT_rt_release_master);
   335 
   349 
   336 /*****************************************************************************/
   350 /*****************************************************************************/
       
   351 
       
   352 /* Emacs-Konfiguration
       
   353 ;;; Local Variables: ***
       
   354 ;;; c-basic-offset:2 ***
       
   355 ;;; End: ***
       
   356 */