[haiku-commits] haiku: hrev44720 - src/add-ons/kernel/busses/ata/promise_tx2

  • From: axeld@xxxxxxxxxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Fri, 26 Oct 2012 12:20:08 +0200 (CEST)

hrev44720 adds 1 changeset to branch 'master'
old head: bf855d375436ff92c46aadde91750df10aae439e
new head: 5262b98eab66734cbbf3055f5ff61b377ac7fa6c

----------------------------------------------------------------------------

5262b98: Converted the promise_tx2 driver to the device manager.
  
  * This is part of ticket #9087. I have not added it to the image yet, before
    it's getting tested, though.

                                   [ Axel DÃrfler <axeld@xxxxxxxxxxxxxxxx> ]

----------------------------------------------------------------------------

Revision:    hrev44720
Commit:      5262b98eab66734cbbf3055f5ff61b377ac7fa6c
URL:         http://cgit.haiku-os.org/haiku/commit/?id=5262b98
Author:      Axel DÃrfler <axeld@xxxxxxxxxxxxxxxx>
Date:        Fri Oct 26 10:18:42 2012 UTC

Ticket:      https://dev.haiku-os.org/ticket/9087

----------------------------------------------------------------------------

2 files changed, 99 insertions(+), 110 deletions(-)
src/add-ons/kernel/busses/ata/Jamfile              |    2 +-
.../kernel/busses/ata/promise_tx2/promise_tx2.c    |  207 ++++++++--------

----------------------------------------------------------------------------

diff --git a/src/add-ons/kernel/busses/ata/Jamfile 
b/src/add-ons/kernel/busses/ata/Jamfile
index 1eb6dfd..2159c1b 100644
--- a/src/add-ons/kernel/busses/ata/Jamfile
+++ b/src/add-ons/kernel/busses/ata/Jamfile
@@ -3,6 +3,6 @@ SubDir HAIKU_TOP src add-ons kernel busses ata ;
 SubInclude HAIKU_TOP src add-ons kernel busses ata generic_ide_pci ;
 SubInclude HAIKU_TOP src add-ons kernel busses ata ide_isa ;
 SubInclude HAIKU_TOP src add-ons kernel busses ata it8211 ;
-#SubInclude HAIKU_TOP src add-ons kernel busses ata promise_tx2 ;
+SubInclude HAIKU_TOP src add-ons kernel busses ata promise_tx2 ;
 SubInclude HAIKU_TOP src add-ons kernel busses ata silicon_image_3112 ;
 SubInclude HAIKU_TOP src add-ons kernel busses ata legacy_sata ;
diff --git a/src/add-ons/kernel/busses/ata/promise_tx2/promise_tx2.c 
b/src/add-ons/kernel/busses/ata/promise_tx2/promise_tx2.c
index d90ffff..c97cb32 100644
--- a/src/add-ons/kernel/busses/ata/promise_tx2/promise_tx2.c
+++ b/src/add-ons/kernel/busses/ata/promise_tx2/promise_tx2.c
@@ -21,65 +21,70 @@
 
 #include "wrapper.h"
 
-#define PROMISE_TX2_CONTROLLER_MODULE_NAME "busses/ata/promise_tx2/device_v1"
+#define PROMISE_TX2_CONTROLLER_MODULE_NAME "busses/ata/promise_tx2/driver_v1"
 #define PROMISE_TX2_CHANNEL_MODULE_NAME "busses/ata/promise_tx2/channel/v1"
 
 
-static ata_for_controller_interface *ide;
-static ata_adapter_interface *ata_adapter;
-static device_manager_info *pnp;
+static ata_for_controller_interface *sATA;
+static ata_adapter_interface *sATAAdapter;
+static device_manager_info *sDeviceManager;
+
+
+static void
+set_channel(void *cookie, ata_channel channel)
+{
+       sATAAdapter->set_channel((ata_adapter_channel_info *)cookie, channel);
+}
 
 
 static status_t
 write_command_block_regs(void *channel_cookie, ata_task_file *tf, ata_reg_mask 
mask)
 {
-       return ata_adapter->write_command_block_regs((ata_adapter_channel_info 
*)channel_cookie, tf, mask);
+       return sATAAdapter->write_command_block_regs((ata_adapter_channel_info 
*)channel_cookie, tf, mask);
 }
 
 
 static status_t
 read_command_block_regs(void *channel_cookie, ata_task_file *tf, ata_reg_mask 
mask)
 {
-       return ata_adapter->read_command_block_regs((ata_adapter_channel_info 
*)channel_cookie, tf, mask);
+       return sATAAdapter->read_command_block_regs((ata_adapter_channel_info 
*)channel_cookie, tf, mask);
 }
 
 
 static uint8
 get_altstatus(void *channel_cookie)
 {
-       return ata_adapter->get_altstatus((ata_adapter_channel_info 
*)channel_cookie);
+       return sATAAdapter->get_altstatus((ata_adapter_channel_info 
*)channel_cookie);
 }
 
 
 static status_t
 write_device_control(void *channel_cookie, uint8 val)
 {
-       return ata_adapter->write_device_control((ata_adapter_channel_info 
*)channel_cookie, val);
+       return sATAAdapter->write_device_control((ata_adapter_channel_info 
*)channel_cookie, val);
 }
 
 
 static status_t
 write_pio(void *channel_cookie, uint16 *data, int count, bool force_16bit)
 {
-       return ata_adapter->write_pio((ata_adapter_channel_info 
*)channel_cookie, data, count, force_16bit);
+       return sATAAdapter->write_pio((ata_adapter_channel_info 
*)channel_cookie, data, count, force_16bit);
 }
 
 
 static status_t
 read_pio(void *channel_cookie, uint16 *data, int count, bool force_16bit)
 {
-       return ata_adapter->read_pio((ata_adapter_channel_info 
*)channel_cookie, data, count, force_16bit);
+       return sATAAdapter->read_pio((ata_adapter_channel_info 
*)channel_cookie, data, count, force_16bit);
 }
 
 
 static int32
-inthand(void *arg)
+handle_interrupt(void *arg)
 {
        ata_adapter_channel_info *channel = (ata_adapter_channel_info *)arg;
        pci_device_module_info *pci = channel->pci;
-       pci_device device = channel->device;
-       ide_bm_status bm_status;
-       uint8 status;
+       pci_device *device = channel->device;
 
        SHOW_FLOW0( 3, "" );
 
@@ -91,7 +96,7 @@ inthand(void *arg)
        if ((pci->read_io_8(device, channel->bus_master_base + 3) & 0x20) == 0)
                return B_UNHANDLED_INTERRUPT;
 
-       return ata_adapter->inthand(arg);
+       return sATAAdapter->inthand(arg);
 }
 
 
@@ -99,88 +104,86 @@ static status_t
 prepare_dma(void *channel_cookie, const physical_entry *sg_list,
        size_t sg_list_count, bool to_device)
 {
-       return ata_adapter->prepare_dma((ata_adapter_channel_info 
*)channel_cookie, sg_list, sg_list_count, to_device);
+       return sATAAdapter->prepare_dma((ata_adapter_channel_info 
*)channel_cookie, sg_list, sg_list_count, to_device);
 }
 
 
 static status_t
 start_dma(void *channel_cookie)
 {
-       return ata_adapter->start_dma((ata_adapter_channel_info 
*)channel_cookie);
+       return sATAAdapter->start_dma((ata_adapter_channel_info 
*)channel_cookie);
 }
 
 
 static status_t
 finish_dma(void *channel_cookie)
 {
-       return ata_adapter->finish_dma((ata_adapter_channel_info 
*)channel_cookie);
+       return sATAAdapter->finish_dma((ata_adapter_channel_info 
*)channel_cookie);
 }
 
 
 static status_t
-init_channel(device_node_handle node, ata_channel ata_channel,
-       void **channel_cookie)
+init_channel(device_node *node, void **channel_cookie)
 {
-       return ata_adapter->init_channel(node, ata_channel, 
(ata_adapter_channel_info **)channel_cookie,
-               sizeof(ata_adapter_channel_info), inthand);
+       return sATAAdapter->init_channel(node,
+               (ata_adapter_channel_info **)channel_cookie,
+               sizeof(ata_adapter_channel_info), handle_interrupt);
 }
 
 
-static status_t
+static void
 uninit_channel(void *channel_cookie)
 {
-       return ata_adapter->uninit_channel((ata_adapter_channel_info 
*)channel_cookie);
+       sATAAdapter->uninit_channel((ata_adapter_channel_info *)channel_cookie);
 }
 
 
-static void channel_removed(device_node_handle node, void *channel_cookie)
+static void channel_removed(void *channel_cookie)
 {
-       return ata_adapter->channel_removed(node, (ata_adapter_channel_info 
*)channel_cookie);
+       return sATAAdapter->channel_removed(
+               (ata_adapter_channel_info *)channel_cookie);
 }
 
 
 static status_t
-init_controller(device_node_handle node, void *user_cookie,
-       ata_adapter_controller_info **cookie)
+init_controller(device_node *node, void **cookie)
 {
-       return ata_adapter->init_controller(node, user_cookie, cookie,
+       return sATAAdapter->init_controller(node,
+               (ata_adapter_controller_info **)cookie,
                sizeof(ata_adapter_controller_info));
 }
 
 
-static status_t
-uninit_controller(ata_adapter_controller_info *controller)
+static void
+uninit_controller(void *controller)
 {
-       return ata_adapter->uninit_controller(controller);
+       sATAAdapter->uninit_controller(
+               (ata_adapter_controller_info *)controller);
 }
 
 
 static void
-controller_removed(device_node_handle node, ata_adapter_controller_info 
*controller)
+controller_removed(void *controller)
 {
-       return ata_adapter->controller_removed(node, controller);
+       return sATAAdapter->controller_removed(
+               (ata_adapter_controller_info *)controller);
 }
 
 
 // publish node of ide controller
 
 static status_t
-publish_controller(device_node_handle parent, uint16 bus_master_base, uint8 
intnum,
-       io_resource_handle *resources, device_node_handle *node)
+publish_controller(device_node *parent, uint16 bus_master_base, uint8 intnum,
+       io_resource *resources, device_node **node)
 {
        device_attr attrs[] = {
-               // info about ourself and our consumer
-               { B_DRIVER_MODULE, B_STRING_TYPE, { string: 
PROMISE_TX2_CONTROLLER_MODULE_NAME }},
-
                // properties of this controller for ide bus manager
                // there are always max. 2 devices
-               { IDE_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { ui8: 2 }},
+               { ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { ui8: 2 }},
                // of course we can DMA
-               { IDE_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: 1 }},
-               // command queuing always works
-               { IDE_CONTROLLER_CAN_CQ_ITEM, B_UINT8_TYPE, { ui8: 1 }},
+               { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: 1 }},
                // choose any name here
-               { IDE_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { string: 
"Promise TX2" }},
+               { ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { string: 
"Promise TX2" }},
 
                // DMA properties
                // some say it must be dword-aligned, others that it can be 
byte-aligned;
@@ -203,19 +206,18 @@ publish_controller(device_node_handle parent, uint16 
bus_master_base, uint8 intn
 
        SHOW_FLOW0(2, "");
 
-       return pnp->register_device(parent, attrs, resources, node);
+       return sDeviceManager->register_node(parent,
+               PROMISE_TX2_CONTROLLER_MODULE_NAME, attrs, resources, node);
 }
 
 
 // detect pure IDE controller, i.e. without channels
 
 static status_t
-detect_controller(pci_device_module_info *pci, pci_device pci_device,
-       device_node_handle parent, uint16 bus_master_base, int8 intnum,
-       device_node_handle *node)
+detect_controller(pci_device_module_info *pci, pci_device *pci_device,
+       device_node *parent, uint16 bus_master_base, int8 intnum,
+       device_node **node)
 {
-       io_resource_handle resource_handles[2];
-
        SHOW_FLOW0(3, "");
 
        if ((bus_master_base & PCI_address_space) != 1)
@@ -225,33 +227,33 @@ detect_controller(pci_device_module_info *pci, pci_device 
pci_device,
 
        {
                io_resource resources[2] = {
-                       { IO_PORT, bus_master_base, 16 },
+                       { B_IO_PORT, bus_master_base, 16 },
                        {}
                };
 
-               if (pnp->acquire_io_resources(resources, resource_handles) != 
B_OK)
-                       return B_ERROR;
+               return publish_controller(parent, bus_master_base, intnum, 
resources,
+                       node);
        }
-
-       return publish_controller(parent, bus_master_base, intnum, 
resource_handles, node);
 }
 
 
 static status_t
-probe_controller(device_node_handle parent)
+probe_controller(device_node *parent)
 {
        pci_device_module_info *pci;
-       pci_device device;
+       pci_device *device;
        uint16 command_block_base[2];
        uint16 control_block_base[2];
        uint16 bus_master_base;
-       device_node_handle controller_node, channels[2];
+       device_node *controller_node;
+       device_node *channels[2];
        uint8 intnum;
-       status_t res;
+       status_t status;
 
        SHOW_FLOW0(3, "");
 
-       if (pnp->init_driver(parent, NULL, (driver_module_info **)&pci, (void 
**)&device) != B_OK)
+       if (sDeviceManager->get_driver(parent, (driver_module_info **)&pci,
+                       (void **)&device) != B_OK)
                return B_ERROR;
 
        command_block_base[0] = pci->read_pci_config(device, 
PCI_base_registers, 4);
@@ -267,99 +269,86 @@ probe_controller(device_node_handle parent)
        control_block_base[1] &= PCI_address_io_mask;
        bus_master_base &= PCI_address_io_mask;
 
-       res = detect_controller(pci, device, parent, bus_master_base, intnum, 
&controller_node);
-       if (res != B_OK || controller_node == NULL)
-               goto err;
+       status = detect_controller(pci, device, parent, bus_master_base, intnum,
+               &controller_node);
+       if (status != B_OK || controller_node == NULL)
+               return status;
 
-       ata_adapter->detect_channel(pci, device, controller_node,
+       sATAAdapter->detect_channel(pci, device, controller_node,
                PROMISE_TX2_CHANNEL_MODULE_NAME, true,
                command_block_base[0], control_block_base[0], bus_master_base, 
intnum,
                0, "Primary Channel", &channels[0], false);
 
-       ata_adapter->detect_channel(pci, device, controller_node,
+       sATAAdapter->detect_channel(pci, device, controller_node,
                PROMISE_TX2_CHANNEL_MODULE_NAME, true,
                command_block_base[1], control_block_base[1], bus_master_base, 
intnum,
                1, "Secondary Channel", &channels[1], false);
 
-       pnp->uninit_driver(parent);
-
        return B_OK;
-
-err:
-       pnp->uninit_driver(parent);
-       return res;
-}
-
-
-static status_t
-std_ops(int32 op, ...)
-{
-       switch (op) {
-               case B_MODULE_INIT:
-               case B_MODULE_UNINIT:
-                       return B_OK;
-
-               default:
-                       return B_ERROR;
-       }
 }
 
 
 module_dependency module_dependencies[] = {
-       { IDE_FOR_CONTROLLER_MODULE_NAME, (module_info **)&ide },
-       { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&pnp },
-       { ATA_ADAPTER_MODULE_NAME, (module_info **)&ata_adapter },
+       { ATA_FOR_CONTROLLER_MODULE_NAME, (module_info **)&sATA },
+       { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
+       { ATA_ADAPTER_MODULE_NAME, (module_info **)&sATAAdapter },
        {}
 };
 
 
 // exported interface
-static ide_controller_interface channel_interface = {
+static ata_controller_interface sChannelInterface = {
        {
                {
                        PROMISE_TX2_CHANNEL_MODULE_NAME,
                        0,
-                       std_ops
+                       NULL
                },
 
-               NULL,   // supported devices
-               NULL,
-               (status_t (*)( device_node_handle , void *, void ** ))  
init_channel,
+               NULL,   // supports_device()
+               NULL,   // register_device()
+               init_channel,
                uninit_channel,
+               NULL,   // register_child_devices()
+               NULL,   // rescan_child_devices()
                channel_removed
        },
 
-       &write_command_block_regs,
-       &read_command_block_regs,
+       set_channel,
 
-       &get_altstatus,
-       &write_device_control,
+       write_command_block_regs,
+       read_command_block_regs,
 
-       &write_pio,
-       &read_pio,
+       get_altstatus,
+       write_device_control,
 
-       &prepare_dma,
-       &start_dma,
-       &finish_dma,
+       write_pio,
+       read_pio,
+
+       prepare_dma,
+       start_dma,
+       finish_dma,
 };
 
 
-static driver_module_info controller_interface = {
+static driver_module_info sControllerInterface = {
        {
                PROMISE_TX2_CONTROLLER_MODULE_NAME,
                0,
-               std_ops
+               NULL
        },
 
        NULL,
        probe_controller,
-       (status_t (*)(device_node_handle, void *, void **))     init_controller,
-       (status_t (*)(void *))                                                  
        uninit_controller,
-       (void (*)(device_node_handle, void *))                          
controller_removed
+       init_controller,
+       uninit_controller,
+       NULL,
+       NULL,
+       controller_removed
 };
 
 module_info *modules[] = {
-       (module_info *)&controller_interface,
-       (module_info *)&channel_interface,
+       (module_info *)&sControllerInterface,
+       (module_info *)&sChannelInterface,
        NULL
 };


Other related posts:

  • » [haiku-commits] haiku: hrev44720 - src/add-ons/kernel/busses/ata/promise_tx2 - axeld