master/slave.c
changeset 960 36e460ffbb5e
parent 928 7fbc0b943c65
child 964 957f21465052
equal deleted inserted replaced
959:676e15bc5f27 960:36e460ffbb5e
    64 /*****************************************************************************/
    64 /*****************************************************************************/
    65 
    65 
    66 /** \cond */
    66 /** \cond */
    67 
    67 
    68 EC_SYSFS_READ_ATTR(info);
    68 EC_SYSFS_READ_ATTR(info);
    69 EC_SYSFS_READ_WRITE_ATTR(state);
       
    70 EC_SYSFS_READ_WRITE_ATTR(sii);
    69 EC_SYSFS_READ_WRITE_ATTR(sii);
    71 EC_SYSFS_READ_WRITE_ATTR(alias);
    70 EC_SYSFS_READ_WRITE_ATTR(alias);
    72 
    71 
    73 static struct attribute *def_attrs[] = {
    72 static struct attribute *def_attrs[] = {
    74     &attr_info,
    73     &attr_info,
    75     &attr_state,
       
    76     &attr_sii,
    74     &attr_sii,
    77     &attr_alias,
    75     &attr_alias,
    78     NULL,
    76     NULL,
    79 };
    77 };
    80 
    78 
  1080 {
  1078 {
  1081     ec_slave_t *slave = container_of(kobj, ec_slave_t, kobj);
  1079     ec_slave_t *slave = container_of(kobj, ec_slave_t, kobj);
  1082 
  1080 
  1083     if (attr == &attr_info) {
  1081     if (attr == &attr_info) {
  1084         return ec_slave_info(slave, buffer);
  1082         return ec_slave_info(slave, buffer);
  1085     }
  1083     } else if (attr == &attr_sii) {
  1086     else if (attr == &attr_state) {
       
  1087         switch (slave->current_state) {
       
  1088             case EC_SLAVE_STATE_INIT:
       
  1089                 return sprintf(buffer, "INIT\n");
       
  1090             case EC_SLAVE_STATE_PREOP:
       
  1091                 return sprintf(buffer, "PREOP\n");
       
  1092             case EC_SLAVE_STATE_SAFEOP:
       
  1093                 return sprintf(buffer, "SAFEOP\n");
       
  1094             case EC_SLAVE_STATE_OP:
       
  1095                 return sprintf(buffer, "OP\n");
       
  1096             default:
       
  1097                 return sprintf(buffer, "UNKNOWN\n");
       
  1098         }
       
  1099     }
       
  1100     else if (attr == &attr_sii) {
       
  1101         if (slave->sii_data) {
  1084         if (slave->sii_data) {
  1102             if (slave->sii_size > PAGE_SIZE) {
  1085             if (slave->sii_size > PAGE_SIZE) {
  1103                 EC_ERR("SII contents of slave %u exceed 1 page (%u/%u).\n",
  1086                 EC_ERR("SII contents of slave %u exceed 1 page (%u/%u).\n",
  1104                        slave->ring_position, slave->sii_size,
  1087                        slave->ring_position, slave->sii_size,
  1105                        (int) PAGE_SIZE);
  1088                        (int) PAGE_SIZE);
  1107             else {
  1090             else {
  1108                 memcpy(buffer, slave->sii_data, slave->sii_size);
  1091                 memcpy(buffer, slave->sii_data, slave->sii_size);
  1109                 return slave->sii_size;
  1092                 return slave->sii_size;
  1110             }
  1093             }
  1111         }
  1094         }
  1112     }
  1095     } else if (attr == &attr_alias) {
  1113     else if (attr == &attr_alias) {
       
  1114         return sprintf(buffer, "%u\n", slave->sii.alias);
  1096         return sprintf(buffer, "%u\n", slave->sii.alias);
  1115     }
  1097     }
  1116 
  1098 
  1117     return 0;
  1099     return 0;
  1118 }
  1100 }
  1130                                  size_t size /**< size of data to store */
  1112                                  size_t size /**< size of data to store */
  1131                                  )
  1113                                  )
  1132 {
  1114 {
  1133     ec_slave_t *slave = container_of(kobj, ec_slave_t, kobj);
  1115     ec_slave_t *slave = container_of(kobj, ec_slave_t, kobj);
  1134 
  1116 
  1135     if (attr == &attr_state) {
  1117     if (attr == &attr_sii) {
  1136         char state[EC_STATE_STRING_SIZE];
       
  1137         if (!strcmp(buffer, "INIT\n"))
       
  1138             ec_slave_request_state(slave, EC_SLAVE_STATE_INIT);
       
  1139         else if (!strcmp(buffer, "PREOP\n"))
       
  1140             ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);
       
  1141         else if (!strcmp(buffer, "SAFEOP\n"))
       
  1142             ec_slave_request_state(slave, EC_SLAVE_STATE_SAFEOP);
       
  1143         else if (!strcmp(buffer, "OP\n"))
       
  1144             ec_slave_request_state(slave, EC_SLAVE_STATE_OP);
       
  1145         else {
       
  1146             EC_ERR("Invalid slave state \"%s\"!\n", buffer);
       
  1147             return -EINVAL;
       
  1148         }
       
  1149 
       
  1150         ec_state_string(slave->requested_state, state);
       
  1151         EC_INFO("Accepted new state %s for slave %u.\n",
       
  1152                 state, slave->ring_position);
       
  1153         return size;
       
  1154     }
       
  1155     else if (attr == &attr_sii) {
       
  1156         return ec_slave_write_sii(slave, buffer, size);
  1118         return ec_slave_write_sii(slave, buffer, size);
  1157     }
  1119     } else if (attr == &attr_alias) {
  1158     else if (attr == &attr_alias) {
       
  1159         return ec_slave_write_alias(slave, buffer, size);
  1120         return ec_slave_write_alias(slave, buffer, size);
  1160     }
  1121     }
  1161 
  1122 
  1162     return -EIO;
  1123     return -EIO;
  1163 }
  1124 }