master/slave.c
changeset 256 dc71aee17f8a
parent 251 c1d0b63a9302
child 260 5fe7df7f2433
equal deleted inserted replaced
255:6b916cce7f27 256:dc71aee17f8a
    52 
    52 
    53 /*****************************************************************************/
    53 /*****************************************************************************/
    54 
    54 
    55 int ec_slave_fetch_categories(ec_slave_t *);
    55 int ec_slave_fetch_categories(ec_slave_t *);
    56 ssize_t ec_show_slave_attribute(struct kobject *, struct attribute *, char *);
    56 ssize_t ec_show_slave_attribute(struct kobject *, struct attribute *, char *);
       
    57 ssize_t ec_store_slave_attribute(struct kobject *, struct attribute *,
       
    58                                  const char *, size_t);
    57 
    59 
    58 /*****************************************************************************/
    60 /*****************************************************************************/
    59 
    61 
    60 /** \cond */
    62 /** \cond */
    61 
    63 
    64 EC_SYSFS_READ_ATTR(vendor_name);
    66 EC_SYSFS_READ_ATTR(vendor_name);
    65 EC_SYSFS_READ_ATTR(product_name);
    67 EC_SYSFS_READ_ATTR(product_name);
    66 EC_SYSFS_READ_ATTR(product_desc);
    68 EC_SYSFS_READ_ATTR(product_desc);
    67 EC_SYSFS_READ_ATTR(sii_desc);
    69 EC_SYSFS_READ_ATTR(sii_desc);
    68 EC_SYSFS_READ_ATTR(type);
    70 EC_SYSFS_READ_ATTR(type);
       
    71 EC_SYSFS_READ_WRITE_ATTR(state);
    69 
    72 
    70 static struct attribute *def_attrs[] = {
    73 static struct attribute *def_attrs[] = {
    71     &attr_ring_position,
    74     &attr_ring_position,
    72     &attr_coupler_address,
    75     &attr_coupler_address,
    73     &attr_vendor_name,
    76     &attr_vendor_name,
    74     &attr_product_name,
    77     &attr_product_name,
    75     &attr_product_desc,
    78     &attr_product_desc,
    76     &attr_sii_desc,
    79     &attr_sii_desc,
    77     &attr_type,
    80     &attr_type,
       
    81     &attr_state,
    78     NULL,
    82     NULL,
    79 };
    83 };
    80 
    84 
    81 static struct sysfs_ops sysfs_ops = {
    85 static struct sysfs_ops sysfs_ops = {
    82     .show = &ec_show_slave_attribute,
    86     .show = ec_show_slave_attribute,
    83     .store = NULL
    87     .store = ec_store_slave_attribute
    84 };
    88 };
    85 
    89 
    86 static struct kobj_type ktype_ec_slave = {
    90 static struct kobj_type ktype_ec_slave = {
    87     .release = ec_slave_clear,
    91     .release = ec_slave_clear,
    88     .sysfs_ops = &sysfs_ops,
    92     .sysfs_ops = &sysfs_ops,
  1258                 return sprintf(buffer, "coupler\n");
  1262                 return sprintf(buffer, "coupler\n");
  1259             else
  1263             else
  1260                 return sprintf(buffer, "normal\n");
  1264                 return sprintf(buffer, "normal\n");
  1261         }
  1265         }
  1262     }
  1266     }
       
  1267     else if (attr == &attr_state) {
       
  1268         switch (slave->current_state) {
       
  1269             case EC_SLAVE_STATE_INIT:
       
  1270                 return sprintf(buffer, "INIT\n");
       
  1271             case EC_SLAVE_STATE_PREOP:
       
  1272                 return sprintf(buffer, "PREOP\n");
       
  1273             case EC_SLAVE_STATE_SAVEOP:
       
  1274                 return sprintf(buffer, "SAVEOP\n");
       
  1275             case EC_SLAVE_STATE_OP:
       
  1276                 return sprintf(buffer, "OP\n");
       
  1277             default:
       
  1278                 return sprintf(buffer, "UNKNOWN\n");
       
  1279         }
       
  1280     }
  1263 
  1281 
  1264     return 0;
  1282     return 0;
       
  1283 }
       
  1284 
       
  1285 /*****************************************************************************/
       
  1286 
       
  1287 /**
       
  1288    Formats attribute data for SysFS write access.
       
  1289    \return number of bytes processed, or negative error code
       
  1290 */
       
  1291 
       
  1292 ssize_t ec_store_slave_attribute(struct kobject *kobj, /**< slave's kobject */
       
  1293                                  struct attribute *attr, /**< attribute */
       
  1294                                  const char *buffer, /**< memory with data */
       
  1295                                  size_t size /**< size of data to store */
       
  1296                                  )
       
  1297 {
       
  1298     ec_slave_t *slave = container_of(kobj, ec_slave_t, kobj);
       
  1299 
       
  1300     if (attr == &attr_state) {
       
  1301         if (!strcmp(buffer, "INIT\n")) {
       
  1302             slave->requested_state = EC_SLAVE_STATE_INIT;
       
  1303             return size;
       
  1304         }
       
  1305         else if (!strcmp(buffer, "PREOP\n")) {
       
  1306             slave->requested_state = EC_SLAVE_STATE_PREOP;
       
  1307             return size;
       
  1308         }
       
  1309         else if (!strcmp(buffer, "SAVEOP\n")) {
       
  1310             slave->requested_state = EC_SLAVE_STATE_SAVEOP;
       
  1311             return size;
       
  1312         }
       
  1313         else if (!strcmp(buffer, "OP\n")) {
       
  1314             slave->requested_state = EC_SLAVE_STATE_OP;
       
  1315             return size;
       
  1316         }
       
  1317 
       
  1318         EC_ERR("Failed to set slave state!\n");
       
  1319     }
       
  1320 
       
  1321     return -EINVAL;
  1265 }
  1322 }
  1266 
  1323 
  1267 /******************************************************************************
  1324 /******************************************************************************
  1268  *  Realtime interface
  1325  *  Realtime interface
  1269  *****************************************************************************/
  1326  *****************************************************************************/