etherlabmaster: comparison master/module.c

equal deleted inserted replaced

-:63bef67e812b
+:fdb85a806585
 return 1;
 }
 /*****************************************************************************/
+/** Maximum MAC string size.
+*/
+#define EC_MAX_MAC_STRING_SIZE (3 * ETH_ALEN)
 /** Print a MAC address to a buffer.
+*
+* The buffer size must be at least EC_MAX_MAC_STRING_SIZE.
 *
 * \return number of bytes written.
 */
 ssize_t ec_mac_print(
 const uint8_t *mac, /**< MAC address */
-char *buffer /**< target buffer */
+char *buffer /**< Target buffer. */
 )
 {
 off_t off = 0;
 unsigned int i;
 /*****************************************************************************/
 /** Parse a MAC address from a string.
 *
-* The MAC address must follow the regexp
+* The MAC address must match the regular expression
 * "([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}".
 *
 * \return 0 on success, else < 0
 */
 static int ec_mac_parse(uint8_t *mac, const char *src, int allow_empty)
 char *rem;
 if (!strlen(src)) {
 if (allow_empty){
 return 0;
-}
+} else {
-else {
 EC_ERR("MAC address may not be empty.\n");
 return -EINVAL;
 }
 }
 || (i < ETH_ALEN - 1 && *rem != ':')) {
 EC_ERR("Invalid MAC address \"%s\".\n", orig);
 return -EINVAL;
 }
 mac[i] = value;
-if (i < ETH_ALEN - 1)
+if (i < ETH_ALEN - 1) {
 src = rem + 1; // skip colon
+}
 }
 return 0;
 }
 /******************************************************************************
 *  Device interface
 *****************************************************************************/
+/** Device names.
+*/
+const char *ec_device_names[EC_NUM_DEVICES] = {
+"main",
+"backup"
+};
 /** Offers an EtherCAT device to a certain master.
 *
 * The master decides, if it wants to use the device for EtherCAT operation,
 * or not. It is important, that the offered net_device is not used by the
 * kernel IP stack. If the master, accepted the offer, the address of the
 ec_pollfunc_t poll, /**< device poll function */
 struct module *module /**< pointer to the module */
 )
 {
 ec_master_t *master;
-char str[20];
+char str[EC_MAX_MAC_STRING_SIZE];
-unsigned int i;
+unsigned int i, j;
 for (i = 0; i < master_count; i++) {
 master = &masters[i];
+ec_mac_print(net_dev->dev_addr, str);
 down(&master->device_sem);
-if (master->main_device.dev) { // master already has a device
-up(&master->device_sem);
+for (j = 0; j < EC_NUM_DEVICES; j++) {
-continue;
+if (!master->devices[j].dev
-}
+&& (ec_mac_equal(master->macs[j], net_dev->dev_addr)
+|| ec_mac_is_broadcast(master->macs[j]))) {
-if (ec_mac_equal(master->main_mac, net_dev->dev_addr)
-|| ec_mac_is_broadcast(master->main_mac)) {
+EC_INFO("Accepting %s as %s device for master %u.\n",
-ec_mac_print(net_dev->dev_addr, str);
+str, ec_device_names[j], master->index);
-EC_INFO("Accepting device %s for master %u.\n",
-str, master->index);
+ec_device_attach(&master->devices[j], net_dev, poll, module);
+up(&master->device_sem);
-ec_device_attach(&master->main_device, net_dev, poll, module);
-up(&master->device_sem);
+snprintf(net_dev->name, IFNAMSIZ, "ec%c%u",
+ec_device_names[j][0], master->index);
-snprintf(net_dev->name, IFNAMSIZ, "ec%u", master->index);
+return &master->devices[j]; // offer accepted
-return &master->main_device; // offer accepted
-}
-else {
-up(&master->device_sem);
-if (master->debug_level) {
-ec_mac_print(net_dev->dev_addr, str);
-EC_MASTER_DBG(master, 0, "Master declined device %s.\n",
-str);
 }
 }
+up(&master->device_sem);
+EC_MASTER_DBG(master, 1, "Master declined device %s.\n", str);
 }
 return NULL; // offer declined
 }
 /******************************************************************************
-*  Realtime interface
+* Application interface
 *****************************************************************************/
 /** Request a master.
 *
 * Same as ecrt_request_master(), but with ERR_PTR() return value.
 ec_master_t *ecrt_request_master_err(
 unsigned int master_index /**< Master index. */
 )
 {
 ec_master_t *master, *errptr = NULL;
+unsigned int i, got_modules = 0;
 EC_INFO("Requesting master %u...\n", master_index);
 if (master_index >= master_count) {
 EC_ERR("Invalid master index %u.\n", master_index);
 EC_MASTER_ERR(master, "Master still waiting for devices!\n");
 errptr = ERR_PTR(-ENODEV);
 goto out_release;
 }
-if (!try_module_get(master->main_device.module)) {
+for (i = 0; i < EC_NUM_DEVICES; i++) {
-up(&master->device_sem);
+ec_device_t *device = &master->devices[i];
-EC_ERR("Device module is unloading!\n");
+if (device->dev) {
-errptr = ERR_PTR(-ENODEV);
+if (!try_module_get(device->module)) {
-goto out_release;
+up(&master->device_sem);
+EC_MASTER_ERR(master, "Device module is unloading!\n");
+errptr = ERR_PTR(-ENODEV);
+goto out_module_put;
+}
+}
+got_modules++;
 }
 up(&master->device_sem);
 if (ec_master_enter_operation_phase(master)) {
 EC_INFO("Successfully requested master %u.\n", master_index);
 return master;
 out_module_put:
-module_put(master->main_device.module);
+for (; got_modules > 0; got_modules--) {
+ec_device_t *device = &master->devices[i - 1];
+if (device->dev) {
+module_put(device->module);
+}
+}
 out_release:
 master->reserved = 0;
 out_return:
 return errptr;
 }
 /*****************************************************************************/
 void ecrt_release_master(ec_master_t *master)
 {
+unsigned int i;
 EC_MASTER_INFO(master, "Releasing master...\n");
 if (!master->reserved) {
 EC_MASTER_WARN(master, "%s(): Master was was not requested!\n",
 __func__);
 return;
 }
 ec_master_leave_operation_phase(master);
-module_put(master->main_device.module);
+for (i = 0; i < EC_NUM_DEVICES; i++) {
+if (master->devices[i].dev) {
+module_put(master->devices[i].module);
+}
+}
 master->reserved = 0;
 EC_MASTER_INFO(master, "Released.\n");
 }

branch	stable-1.5
changeset 2419	fdb85a806585
parent 2382	2565cb4d9e31
parent 2374	e898451c054a
child 2453	d461b1f07296