etherlabmaster: comparison master/module.c

equal deleted inserted replaced

-:af21f0bdc7c9
+:2b9c78543663
 static char *backup_devices[MAX_MASTERS]; /**< Backup devices parameter. */
 static unsigned int backup_count; /**< Number of backup devices. */
 static unsigned int debug_level;  /**< Debug level parameter. */
 static ec_master_t *masters; /**< Array of masters. */
-static struct ec_mutex_t master_mutex; /**< Master mutex. */
+static struct semaphore master_sem; /**< Master semaphore. */
 dev_t device_number; /**< Device number for master cdevs. */
 struct class *class; /**< Device class. */
 static uint8_t macs[MAX_MASTERS][2][ETH_ALEN]; /**< MAC addresses. */
 {
 int i, ret = 0;
 EC_INFO("Master driver %s\n", EC_MASTER_VERSION);
-ec_mutex_init(&master_mutex);
+sema_init(&master_sem, 1);
 if (master_count) {
 if (alloc_chrdev_region(&device_number,
 0, master_count, "EtherCAT")) {
 EC_ERR("Failed to obtain device number(s)!\n");
 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;
 }
 }
 /*****************************************************************************/
 /** Prints slave states in clear text.
+*
+* \return Size of the created string.
 */
 size_t ec_state_string(uint8_t states, /**< slave states */
 char *buffer, /**< target buffer
 (min. EC_STATE_STRING_SIZE bytes) */
 uint8_t multi /**< Show multi-state mask. */
 /******************************************************************************
 *  Device interface
 *****************************************************************************/
+/** Device names.
+*/
+const char *ec_device_names[2] = {
+"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, dev_idx;
 for (i = 0; i < master_count; i++) {
 master = &masters[i];
+ec_mac_print(net_dev->dev_addr, str);
-ec_mutex_lock(&master->device_mutex);
-if (master->main_device.dev) { // master already has a device
+if (down_interruptible(&master->device_sem)) {
-ec_mutex_unlock(&master->device_mutex);
+EC_MASTER_WARN(master, "%s() interrupted!\n", __func__);
-continue;
+return NULL;
 }
-if (ec_mac_equal(master->main_mac, net_dev->dev_addr)
+for (dev_idx = EC_DEVICE_MAIN;
-|| ec_mac_is_broadcast(master->main_mac)) {
+dev_idx < ec_master_num_devices(master); dev_idx++) {
-ec_mac_print(net_dev->dev_addr, str);
+if (!master->devices[dev_idx].dev
-EC_INFO("Accepting device %s for master %u.\n",
+&& (ec_mac_equal(master->macs[dev_idx], net_dev->dev_addr)
-str, master->index);
+|| ec_mac_is_broadcast(master->macs[dev_idx]))) {
-ec_device_attach(&master->main_device, net_dev, poll, module);
+EC_INFO("Accepting %s as %s device for master %u.\n",
-ec_mutex_unlock(&master->device_mutex);
+str, ec_device_names[dev_idx != 0], master->index);
-snprintf(net_dev->name, IFNAMSIZ, "ec%u", master->index);
+ec_device_attach(&master->devices[dev_idx],
+net_dev, poll, module);
-return &master->main_device; // offer accepted
+up(&master->device_sem);
-}
-else {
+snprintf(net_dev->name, IFNAMSIZ, "ec%c%u",
-ec_mutex_unlock(&master->device_mutex);
+ec_device_names[dev_idx != 0][0], master->index);
-if (master->debug_level) {
+return &master->devices[dev_idx]; // offer accepted
-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.
+*
+* \return Requested master.
 */
 ec_master_t *ecrt_request_master_err(
 unsigned int master_index /**< Master index. */
 )
 {
 ec_master_t *master, *errptr = NULL;
+unsigned int dev_idx = EC_DEVICE_MAIN;
 EC_INFO("Requesting master %u...\n", master_index);
 if (master_index >= master_count) {
 EC_ERR("Invalid master index %u.\n", master_index);
 errptr = ERR_PTR(-EINVAL);
 goto out_return;
 }
 master = &masters[master_index];
-if (ec_mutex_lock_interruptible(&master_mutex)) {
+if (down_interruptible(&master_sem)) {
 errptr = ERR_PTR(-EINTR);
 goto out_return;
 }
 if (master->reserved) {
-ec_mutex_unlock(&master_mutex);
+up(&master_sem);
 EC_MASTER_ERR(master, "Master already in use!\n");
 errptr = ERR_PTR(-EBUSY);
 goto out_return;
 }
 master->reserved = 1;
-ec_mutex_unlock(&master_mutex);
+up(&master_sem);
-if (ec_mutex_lock_interruptible(&master->device_mutex)) {
+if (down_interruptible(&master->device_sem)) {
 errptr = ERR_PTR(-EINTR);
 goto out_release;
 }
 if (master->phase != EC_IDLE) {
-ec_mutex_unlock(&master->device_mutex);
+up(&master->device_sem);
 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 (; dev_idx < ec_master_num_devices(master); dev_idx++) {
-ec_mutex_unlock(&master->device_mutex);
+ec_device_t *device = &master->devices[dev_idx];
-EC_ERR("Device module is unloading!\n");
+if (!try_module_get(device->module)) {
-errptr = ERR_PTR(-ENODEV);
+up(&master->device_sem);
-goto out_release;
+EC_MASTER_ERR(master, "Device module is unloading!\n");
-}
+errptr = ERR_PTR(-ENODEV);
+goto out_module_put;
-ec_mutex_unlock(&master->device_mutex);
+}
+}
+up(&master->device_sem);
 if (ec_master_enter_operation_phase(master)) {
 EC_MASTER_ERR(master, "Failed to enter OPERATION phase!\n");
 errptr = ERR_PTR(-EIO);
 goto out_module_put;
 EC_INFO("Successfully requested master %u.\n", master_index);
 return master;
 out_module_put:
-module_put(master->main_device.module);
+for (; dev_idx > 0; dev_idx--) {
+ec_device_t *device = &master->devices[dev_idx - 1];
+module_put(device->module);
+}
 out_release:
 master->reserved = 0;
 out_return:
 return errptr;
 }
 /*****************************************************************************/
 void ecrt_release_master(ec_master_t *master)
 {
+unsigned int dev_idx;
 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 (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
+dev_idx++) {
+module_put(master->devices[dev_idx].module);
+}
 master->reserved = 0;
 EC_MASTER_INFO(master, "Released.\n");
 }
 /*****************************************************************************/
 unsigned int ecrt_version_magic(void)
 {
 return ECRT_VERSION_MAGIC;
-}
-/*****************************************************************************/
-/** Return pointer to running master
-*/
-ec_master_t *ecrt_attach_master(unsigned int master_index)
-{
-ec_master_t *master = NULL;
-EC_INFO("Requesting master %u...\n", master_index);
-if (master_index >= master_count) {
-EC_ERR("Invalid master index %u.\n", master_index);
-return master;
-}
-master = &masters[master_index];
-if (master->reserved) {
-// ok master is attached
-EC_INFO("attaching Master %u!\n", master_index);
-} else {
-EC_ERR("No Master %u in use!\n", master_index);
-master = NULL;
-}
-return master;
 }
 /*****************************************************************************/
 /** Global request state type translation table.
 EXPORT_SYMBOL(ecdev_offer);
 EXPORT_SYMBOL(ecrt_request_master);
 EXPORT_SYMBOL(ecrt_release_master);
 EXPORT_SYMBOL(ecrt_version_magic);
-EXPORT_SYMBOL(ecrt_attach_master);
 /** \endcond */
 /*****************************************************************************/

changeset 2589	2b9c78543663
parent 2411	01370d59233d