etherlabmaster: comparison master/cdev.c

equal deleted inserted replaced

-:ea38efeeb7b3
+:6aa393418fb3
 cdev->cdev.owner = THIS_MODULE;
 ret = cdev_add(&cdev->cdev,
 MKDEV(MAJOR(dev_num), master->index), 1);
 if (ret) {
-EC_ERR("Failed to add character device!\n");
+EC_MASTER_ERR(master, "Failed to add character device!\n");
 }
 return ret;
 }
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n", data.position);
 return -EINVAL;
 }
 data.vendor_id = slave->sii.vendor_id;
 data.product_code = slave->sii.product_code;
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 if (data.sync_index >= slave->sii.sync_count) {
 up(&master->master_sem);
-EC_ERR("Sync manager %u does not exist in slave %u!\n",
+EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",
-data.sync_index, data.slave_position);
+data.sync_index);
 return -EINVAL;
 }
 sync = &slave->sii.syncs[data.sync_index];
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 if (data.sync_index >= slave->sii.sync_count) {
 up(&master->master_sem);
-EC_ERR("Sync manager %u does not exist in slave %u!\n",
+EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",
-data.sync_index, data.slave_position);
+data.sync_index);
 return -EINVAL;
 }
 sync = &slave->sii.syncs[data.sync_index];
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sync->pdos, data.pdo_pos))) {
 up(&master->master_sem);
-EC_ERR("Sync manager %u does not contain a PDO with "
+EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with "
-"position %u in slave %u!\n", data.sync_index,
+"position %u!\n", data.sync_index, data.pdo_pos);
-data.pdo_pos, data.slave_position);
 return -EINVAL;
 }
 data.index = pdo->index;
 data.entry_count = ec_pdo_entry_count(pdo);
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 if (data.sync_index >= slave->sii.sync_count) {
 up(&master->master_sem);
-EC_ERR("Sync manager %u does not exist in slave %u!\n",
+EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",
-data.sync_index, data.slave_position);
+data.sync_index);
 return -EINVAL;
 }
 sync = &slave->sii.syncs[data.sync_index];
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sync->pdos, data.pdo_pos))) {
 up(&master->master_sem);
-EC_ERR("Sync manager %u does not contain a PDO with "
+EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with "
-"position %u in slave %u!\n", data.sync_index,
+"position %u!\n", data.sync_index, data.pdo_pos);
-data.pdo_pos, data.slave_position);
 return -EINVAL;
 }
 if (!(entry = ec_pdo_find_entry_by_pos_const(
 pdo, data.entry_pos))) {
 up(&master->master_sem);
-EC_ERR("PDO 0x%04X does not contain an entry with "
+EC_SLAVE_ERR(slave, "PDO 0x%04X does not contain an entry with "
-"position %u in slave %u!\n", data.pdo_pos,
+"position %u!\n", data.pdo_pos, data.entry_pos);
-data.entry_pos, data.slave_position);
 return -EINVAL;
 }
 data.index = entry->index;
 data.subindex = entry->subindex;
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.index))) {
 up(&master->master_sem);
-EC_ERR("Domain %u does not exist!\n", data.index);
+EC_MASTER_ERR(master, "Domain %u does not exist!\n", data.index);
 return -EINVAL;
 }
 data.data_size = domain->data_size;
 data.tx_size = domain->tx_size;
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {
 up(&master->master_sem);
-EC_ERR("Domain %u does not exist!\n", data.domain_index);
+EC_MASTER_ERR(master, "Domain %u does not exist!\n",
+data.domain_index);
 return -EINVAL;
 }
 if (!(fmmu = ec_domain_find_fmmu(domain, data.fmmu_index))) {
 up(&master->master_sem);
-EC_ERR("Domain %u has less than %u fmmu configurations.\n",
+EC_MASTER_ERR(master, "Domain %u has less than %u"
+" fmmu configurations.\n",
 data.domain_index, data.fmmu_index + 1);
 return -EINVAL;
 }
 data.slave_config_alias = fmmu->sc->alias;
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {
 up(&master->master_sem);
-EC_ERR("Domain %u does not exist!\n", data.domain_index);
+EC_MASTER_ERR(master, "Domain %u does not exist!\n",
+data.domain_index);
 return -EINVAL;
 }
 if (domain->data_size != data.data_size) {
 up(&master->master_sem);
-EC_ERR("Data size mismatch %u/%zu!\n",
+EC_MASTER_ERR(master, "Data size mismatch %u/%zu!\n",
 data.data_size, domain->data_size);
 return -EFAULT;
 }
 if (copy_to_user((void __user *) data.target, domain->data,
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 ec_slave_request_state(slave, data.al_state);
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 if (!(sdo = ec_slave_get_sdo_by_pos_const(
 slave, data.sdo_position))) {
 up(&master->master_sem);
-EC_ERR("SDO %u does not exist in slave %u!\n",
+EC_SLAVE_ERR(slave, "SDO %u does not exist!\n", data.sdo_position);
-data.sdo_position, data.slave_position);
 return -EINVAL;
 }
 data.sdo_index = sdo->index;
 data.max_subindex = sdo->max_subindex;
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 if (data.sdo_spec <= 0) {
 if (!(sdo = ec_slave_get_sdo_by_pos_const(
 slave, -data.sdo_spec))) {
 up(&master->master_sem);
-EC_ERR("SDO %u does not exist in slave %u!\n",
+EC_SLAVE_ERR(slave, "SDO %u does not exist!\n", -data.sdo_spec);
--data.sdo_spec, data.slave_position);
 return -EINVAL;
 }
 } else {
 if (!(sdo = ec_slave_get_sdo_const(
 slave, data.sdo_spec))) {
 up(&master->master_sem);
-EC_ERR("SDO 0x%04X does not exist in slave %u!\n",
+EC_SLAVE_ERR(slave, "SDO 0x%04X does not exist!\n",
-data.sdo_spec, data.slave_position);
+data.sdo_spec);
 return -EINVAL;
 }
 }
 if (!(entry = ec_sdo_get_entry_const(
 sdo, data.sdo_entry_subindex))) {
 up(&master->master_sem);
-EC_ERR("SDO entry 0x%04X:%02X does not exist "
+EC_SLAVE_ERR(slave, "SDO entry 0x%04X:%02X does not exist!\n",
-"in slave %u!\n", sdo->index,
+sdo->index, data.sdo_entry_subindex);
-data.sdo_entry_subindex, data.slave_position);
 return -EINVAL;
 }
 data.data_type = entry->data_type;
 data.bit_length = entry->bit_length;
 if (!(request.slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
 ec_sdo_request_clear(&request.req);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
-return -EINVAL;
+data.slave_position);
-}
+return -EINVAL;
+}
-if (master->debug_level)
-EC_DBG("Schedule SDO upload request for slave %u\n",
+EC_SLAVE_DBG(request.slave, 1, "Schedule SDO upload request.\n");
-request.slave->ring_position);
 // schedule request.
 list_add_tail(&request.list, &request.slave->slave_sdo_requests);
 up(&master->master_sem);
 // wait until master FSM has finished processing
 wait_event(request.slave->sdo_queue,
 request.req.state != EC_INT_REQUEST_BUSY);
-if (master->debug_level)
+EC_SLAVE_DBG(request.slave, 1, "Finished SDO upload request.\n");
-EC_DBG("Scheduled SDO upload request for slave %u done\n",
-request.slave->ring_position);
 data.abort_code = request.req.abort_code;
 if (request.req.state != EC_INT_REQUEST_SUCCESS) {
 data.data_size = 0;
 retval = -EIO;
 } else {
 if (request.req.data_size > data.target_size) {
-EC_ERR("Buffer too small.\n");
+EC_MASTER_ERR(master, "Buffer too small.\n");
 ec_sdo_request_clear(&request.req);
 return -EOVERFLOW;
 }
 data.data_size = request.req.data_size;
 return -EFAULT;
 }
 // copy data to download
 if (!data.data_size) {
-EC_ERR("Zero data size!\n");
+EC_MASTER_ERR(master, "Zero data size!\n");
 return -EINVAL;
 }
 ec_sdo_request_init(&request.req);
 ec_sdo_request_address(&request.req,
 return -EINTR;
 if (!(request.slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 ec_sdo_request_clear(&request.req);
 return -EINVAL;
 }
-if (master->debug_level)
+EC_SLAVE_DBG(request.slave, 1, "Schedule SDO download request.\n");
-EC_DBG("Schedule SDO download request for slave %u\n",
-request.slave->ring_position);
 // schedule request.
 list_add_tail(&request.list, &request.slave->slave_sdo_requests);
 up(&master->master_sem);
 // wait until master FSM has finished processing
 wait_event(request.slave->sdo_queue,
 request.req.state != EC_INT_REQUEST_BUSY);
-if (master->debug_level)
+EC_SLAVE_DBG(request.slave, 1, "Finished SDO download request.\n");
-EC_DBG("Scheduled SDO download request for slave %u done\n",
-request.slave->ring_position);
 data.abort_code = request.req.abort_code;
 retval = request.req.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 if (!data.nwords
 || data.offset + data.nwords > slave->sii_nwords) {
 up(&master->master_sem);
-EC_ERR("Invalid SII read offset/size %u/%u for slave "
+EC_SLAVE_ERR(slave, "Invalid SII read offset/size %u/%u for slave SII"
-"SII size %zu!\n", data.offset,
+" size %zu!\n", data.offset, data.nwords, slave->sii_nwords);
-data.nwords, slave->sii_nwords);
 return -EINVAL;
 }
 if (copy_to_user((void __user *) data.words,
 slave->sii_words + data.offset, data.nwords * 2))
 if (!data.nwords)
 return 0;
 byte_size = sizeof(uint16_t) * data.nwords;
 if (!(words = kmalloc(byte_size, GFP_KERNEL))) {
-EC_ERR("Failed to allocate %u bytes for SII contents.\n",
+EC_MASTER_ERR(master, "Failed to allocate %u bytes"
-byte_size);
+" for SII contents.\n", byte_size);
 return -ENOMEM;
 }
 if (copy_from_user(words,
 (void __user *) data.words, byte_size)) {
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 kfree(words);
 return -EINVAL;
 }
 // init SII write request
 if (!data.length)
 return 0;
 if (!(contents = kmalloc(data.length, GFP_KERNEL))) {
-EC_ERR("Failed to allocate %u bytes for register data.\n",
+EC_MASTER_ERR(master, "Failed to allocate %u bytes"
-data.length);
+" for register data.\n", data.length);
 return -ENOMEM;
 }
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 // init register request
 INIT_LIST_HEAD(&request.list);
 if (!data.length)
 return 0;
 if (!(contents = kmalloc(data.length, GFP_KERNEL))) {
-EC_ERR("Failed to allocate %u bytes for register data.\n",
+EC_MASTER_ERR(master, "Failed to allocate %u bytes"
-data.length);
+" for register data.\n", data.length);
 return -ENOMEM;
 }
 if (copy_from_user(contents, (void __user *) data.data, data.length)) {
 kfree(contents);
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 kfree(contents);
 return -EINVAL;
 }
 // init register request
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
 up(&master->master_sem);
-EC_ERR("Slave config %u does not exist!\n",
+EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 data.alias = sc->alias;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
 if (data.sync_index >= EC_MAX_SYNC_MANAGERS) {
-EC_ERR("Invalid sync manager index %u!\n",
+EC_MASTER_ERR(master, "Invalid sync manager index %u!\n",
 data.sync_index);
 return -EINVAL;
 }
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
 up(&master->master_sem);
-EC_ERR("Slave config %u does not exist!\n",
+EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sc->sync_configs[data.sync_index].pdos,
 data.pdo_pos))) {
 up(&master->master_sem);
-EC_ERR("Invalid PDO position!\n");
+EC_MASTER_ERR(master, "Invalid PDO position!\n");
 return -EINVAL;
 }
 data.index = pdo->index;
 data.entry_count = ec_pdo_entry_count(pdo);
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
 if (data.sync_index >= EC_MAX_SYNC_MANAGERS) {
-EC_ERR("Invalid sync manager index %u!\n",
+EC_MASTER_ERR(master, "Invalid sync manager index %u!\n",
 data.sync_index);
 return -EINVAL;
 }
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
 up(&master->master_sem);
-EC_ERR("Slave config %u does not exist!\n",
+EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sc->sync_configs[data.sync_index].pdos,
 data.pdo_pos))) {
 up(&master->master_sem);
-EC_ERR("Invalid PDO position!\n");
+EC_MASTER_ERR(master, "Invalid PDO position!\n");
 return -EINVAL;
 }
 if (!(entry = ec_pdo_find_entry_by_pos_const(
 pdo, data.entry_pos))) {
 up(&master->master_sem);
-EC_ERR("Entry not found!\n");
+EC_MASTER_ERR(master, "Entry not found!\n");
 return -EINVAL;
 }
 data.index = entry->index;
 data.subindex = entry->subindex;
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
 up(&master->master_sem);
-EC_ERR("Slave config %u does not exist!\n",
+EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(req = ec_slave_config_get_sdo_by_pos_const(
 sc, data.sdo_pos))) {
 up(&master->master_sem);
-EC_ERR("Invalid SDO position!\n");
+EC_MASTER_ERR(master, "Invalid SDO position!\n");
 return -EINVAL;
 }
 data.index = req->index;
 data.subindex = req->subindex;
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(eoe = ec_master_get_eoe_handler_const(master, data.eoe_index))) {
 up(&master->master_sem);
-EC_ERR("EoE handler %u does not exist!\n", data.eoe_index);
+EC_MASTER_ERR(master, "EoE handler %u does not exist!\n",
+data.eoe_index);
 return -EINVAL;
 }
 if (eoe->slave) {
 data.slave_position = eoe->slave->ring_position;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
 if (!data.size) {
-EC_ERR("Sdo download: Data size may not be zero!\n");
+EC_MASTER_ERR(master, "SDO download: Data size may not be zero!\n");
 return -EINVAL;
 }
 if (down_interruptible(&master->master_sem))
 return -EINTR;
 if (!(request.slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
 ec_foe_request_clear(&request.req);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 return -EINVAL;
 }
 // schedule request.
 list_add_tail(&request.list, &request.slave->foe_requests);
 up(&master->master_sem);
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Scheduled FoE read request.\n");
-EC_DBG("Scheduled FoE read request on slave %u.\n",
-request.slave->ring_position);
-}
 // wait for processing through FSM
 if (wait_event_interruptible(request.slave->foe_queue,
 request.req.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
 request.req.state != EC_INT_REQUEST_BUSY);
 data.result = request.req.result;
 data.error_code = request.req.error_code;
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Read %zd bytes via FoE"
-EC_DBG("Read %zd bytes via FoE (result = 0x%x).\n",
+" (result = 0x%x).\n", request.req.data_size, request.req.result);
-request.req.data_size, request.req.result);
-}
 if (request.req.state != EC_INT_REQUEST_SUCCESS) {
 data.data_size = 0;
 retval = -EIO;
 } else {
 if (request.req.data_size > data.buffer_size) {
-EC_ERR("Buffer too small.\n");
+EC_MASTER_ERR(master, "Buffer too small.\n");
 ec_foe_request_clear(&request.req);
 return -EOVERFLOW;
 }
 data.data_size = request.req.data_size;
 if (copy_to_user((void __user *) data.buffer,
 if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {
 retval = -EFAULT;
 }
-if (master->debug_level)
+EC_SLAVE_DBG(request.slave, 1, "Finished FoE read request.\n");
-EC_DBG("FoE read request finished on slave %u.\n",
-request.slave->ring_position);
 ec_foe_request_clear(&request.req);
 return retval;
 }
 return -EINTR;
 if (!(request.slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", data.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+data.slave_position);
 ec_foe_request_clear(&request.req);
 return -EINVAL;
 }
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Scheduling FoE write request.\n");
-EC_DBG("Scheduling FoE write request.\n");
-}
 // schedule FoE write request.
 list_add_tail(&request.list, &request.slave->foe_requests);
 up(&master->master_sem);
 retval = -EFAULT;
 }
 ec_foe_request_clear(&request.req);
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Finished FoE write request.\n");
-EC_DBG("Finished FoE writing.\n");
-}
 return retval;
 }
 /*****************************************************************************/
 if (!(request.slave = ec_master_find_slave(
 master, 0, ioctl.slave_position))) {
 up(&master->master_sem);
 ec_soe_request_clear(&request.req);
-EC_ERR("Slave %u does not exist!\n", ioctl.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+ioctl.slave_position);
 return -EINVAL;
 }
 // schedule request.
 list_add_tail(&request.list, &request.slave->soe_requests);
 up(&master->master_sem);
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Scheduled SoE read request.\n");
-EC_DBG("Scheduled SoE read request on slave %u.\n",
-request.slave->ring_position);
-}
 // wait for processing through FSM
 if (wait_event_interruptible(request.slave->soe_queue,
 request.req.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
 wait_event(request.slave->soe_queue,
 request.req.state != EC_INT_REQUEST_BUSY);
 ioctl.error_code = request.req.error_code;
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Read %zd bytes via SoE.\n",
-EC_DBG("Read %zd bytes via SoE.\n", request.req.data_size);
+request.req.data_size);
-}
 if (request.req.state != EC_INT_REQUEST_SUCCESS) {
 ioctl.data_size = 0;
 retval = -EIO;
 } else {
 if (request.req.data_size > ioctl.mem_size) {
-EC_ERR("Buffer too small.\n");
+EC_MASTER_ERR(master, "Buffer too small.\n");
 ec_soe_request_clear(&request.req);
 return -EOVERFLOW;
 }
 ioctl.data_size = request.req.data_size;
 if (copy_to_user((void __user *) ioctl.data,
 if (__copy_to_user((void __user *) arg, &ioctl, sizeof(ioctl))) {
 retval = -EFAULT;
 }
-if (master->debug_level)
+EC_SLAVE_DBG(request.slave, 1, "Finished SoE read request.\n");
-EC_DBG("SoE read request finished on slave %u.\n",
-request.slave->ring_position);
 ec_soe_request_clear(&request.req);
 return retval;
 }
 return -EINTR;
 if (!(request.slave = ec_master_find_slave(
 master, 0, ioctl.slave_position))) {
 up(&master->master_sem);
-EC_ERR("Slave %u does not exist!\n", ioctl.slave_position);
+EC_MASTER_ERR(master, "Slave %u does not exist!\n",
+ioctl.slave_position);
 ec_soe_request_clear(&request.req);
 return -EINVAL;
 }
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Scheduling SoE write request.\n");
-EC_DBG("Scheduling SoE write request.\n");
-}
 // schedule SoE write request.
 list_add_tail(&request.list, &request.slave->soe_requests);
 up(&master->master_sem);
 retval = -EFAULT;
 }
 ec_soe_request_clear(&request.req);
-if (master->debug_level) {
+EC_SLAVE_DBG(request.slave, 1, "Finished SoE write request.\n");
-EC_DBG("Finished SoE writing.\n");
-}
 return retval;
 }
 /******************************************************************************
 ec_cdev_t *cdev = container_of(inode->i_cdev, ec_cdev_t, cdev);
 ec_cdev_priv_t *priv;
 priv = kmalloc(sizeof(ec_cdev_priv_t), GFP_KERNEL);
 if (!priv) {
-EC_ERR("Failed to allocate memory for private data structure.\n");
+EC_MASTER_ERR(cdev->master,
+"Failed to allocate memory for private data structure.\n");
 return -ENOMEM;
 }
 priv->cdev = cdev;
 priv->requested = 0;
 priv->process_data_size = 0;
 filp->private_data = priv;
 #if DEBUG_IOCTL
-EC_DBG("File opened.\n");
+EC_MASTER_DBG(cdev->master, "File opened.\n");
 #endif
 return 0;
 }
 /*****************************************************************************/
 if (priv->process_data)
 vfree(priv->process_data);
 #if DEBUG_IOCTL
-EC_DBG("File closed.\n");
+EC_MASTER_DBG(master, "File closed.\n");
 #endif
 kfree(priv);
 return 0;
 }
 {
 ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data;
 ec_master_t *master = priv->cdev->master;
 #if DEBUG_IOCTL
-EC_DBG("ioctl(filp = 0x%x, cmd = 0x%08x (0x%02x), arg = 0x%x)\n",
+EC_MASTER_DBG(master, "ioctl(filp = 0x%x, cmd = 0x%08x (0x%02x),"
-(u32) filp, (u32) cmd, (u32) _IOC_NR(cmd), (u32) arg);
+" arg = 0x%x)\n", (u32) filp, (u32) cmd, (u32) _IOC_NR(cmd),
+(u32) arg);
 #endif
 switch (cmd) {
 case EC_IOCTL_MODULE:
 return ec_cdev_ioctl_module(arg);
 case EC_IOCTL_VOE_DATA:
 return ec_cdev_ioctl_voe_data(master, arg, priv);
 case EC_IOCTL_SET_SEND_INTERVAL:
 if (!(filp->f_mode & FMODE_WRITE))
 return -EPERM;
-return ec_cdev_ioctl_set_send_interval(master,arg,priv);
+return ec_cdev_ioctl_set_send_interval(master, arg, priv);
 default:
 return -ENOTTY;
 }
 }
 struct vm_area_struct *vma
 )
 {
 ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data;
-if (priv->cdev->master->debug_level)
+EC_MASTER_DBG(priv->cdev->master, 1, "mmap()\n");
-EC_DBG("mmap()\n");
 vma->vm_ops = &eccdev_vm_ops;
 vma->vm_flags |= VM_RESERVED; /* Pages will not be swapped out */
 vma->vm_private_data = priv;
 return VM_FAULT_SIGBUS;
 get_page(page);
 vmf->page = page;
-if (priv->cdev->master->debug_level)
+EC_MASTER_DBG(priv->cdev->master, 1, "Vma fault, virtual_address = %p,"
-EC_DBG("Vma fault, virtual_address = %p, offset = %lu, page = %p\n",
+" offset = %lu, page = %p\n", vmf->virtual_address, offset, page);
-vmf->virtual_address, offset, page);
 return 0;
 }
 #else
 if (offset >= priv->process_data_size)
 return NOPAGE_SIGBUS;
 page = vmalloc_to_page(priv->process_data + offset);
-if (priv->cdev->master->debug_level)
+EC_MASTER_DBG(master, "Nopage fault vma, address = %#lx,"
-EC_DBG("Nopage fault vma, address = %#lx, offset = %#lx, page = %p\n",
+" offset = %#lx, page = %p\n", address, offset, page);
-address, offset, page);
 get_page(page);
 if (type)
 *type = VM_FAULT_MINOR;

changeset 1989	6aa393418fb3
parent 1984	02c8728bf9e4
parent 1922	99905e297f33
child 1995	7d748d9cf9e8