Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...
[linux-2.6] / drivers / s390 / scsi / zfcp_ccw.c
1 /*
2  * This file is part of the zfcp device driver for
3  * FCP adapters for IBM System z9 and zSeries.
4  *
5  * (C) Copyright IBM Corp. 2002, 2006
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2, or (at your option)
10  * any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #include "zfcp_ext.h"
23
24 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_CONFIG
25
26 static int zfcp_ccw_probe(struct ccw_device *);
27 static void zfcp_ccw_remove(struct ccw_device *);
28 static int zfcp_ccw_set_online(struct ccw_device *);
29 static int zfcp_ccw_set_offline(struct ccw_device *);
30 static int zfcp_ccw_notify(struct ccw_device *, int);
31 static void zfcp_ccw_shutdown(struct ccw_device *);
32
33 static struct ccw_device_id zfcp_ccw_device_id[] = {
34         {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
35                             ZFCP_CONTROL_UNIT_MODEL,
36                             ZFCP_DEVICE_TYPE,
37                             ZFCP_DEVICE_MODEL)},
38         {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
39                             ZFCP_CONTROL_UNIT_MODEL,
40                             ZFCP_DEVICE_TYPE,
41                             ZFCP_DEVICE_MODEL_PRIV)},
42         {},
43 };
44
45 static struct ccw_driver zfcp_ccw_driver = {
46         .owner       = THIS_MODULE,
47         .name        = ZFCP_NAME,
48         .ids         = zfcp_ccw_device_id,
49         .probe       = zfcp_ccw_probe,
50         .remove      = zfcp_ccw_remove,
51         .set_online  = zfcp_ccw_set_online,
52         .set_offline = zfcp_ccw_set_offline,
53         .notify      = zfcp_ccw_notify,
54         .shutdown    = zfcp_ccw_shutdown,
55         .driver = {
56                 .groups = zfcp_driver_attr_groups,
57         },
58 };
59
60 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
61
62 /**
63  * zfcp_ccw_probe - probe function of zfcp driver
64  * @ccw_device: pointer to belonging ccw device
65  *
66  * This function gets called by the common i/o layer and sets up the initial
67  * data structures for each fcp adapter, which was detected by the system.
68  * Also the sysfs files for this adapter will be created by this function.
69  * In addition the nameserver port will be added to the ports of the adapter
70  * and its sysfs representation will be created too.
71  */
72 static int
73 zfcp_ccw_probe(struct ccw_device *ccw_device)
74 {
75         struct zfcp_adapter *adapter;
76         int retval = 0;
77
78         down(&zfcp_data.config_sema);
79         adapter = zfcp_adapter_enqueue(ccw_device);
80         if (!adapter)
81                 retval = -EINVAL;
82         else
83                 ZFCP_LOG_DEBUG("Probed adapter %s\n",
84                                zfcp_get_busid_by_adapter(adapter));
85         up(&zfcp_data.config_sema);
86         return retval;
87 }
88
89 /**
90  * zfcp_ccw_remove - remove function of zfcp driver
91  * @ccw_device: pointer to belonging ccw device
92  *
93  * This function gets called by the common i/o layer and removes an adapter
94  * from the system. Task of this function is to get rid of all units and
95  * ports that belong to this adapter. And in addition all resources of this
96  * adapter will be freed too.
97  */
98 static void
99 zfcp_ccw_remove(struct ccw_device *ccw_device)
100 {
101         struct zfcp_adapter *adapter;
102         struct zfcp_port *port, *p;
103         struct zfcp_unit *unit, *u;
104
105         ccw_device_set_offline(ccw_device);
106         down(&zfcp_data.config_sema);
107         adapter = dev_get_drvdata(&ccw_device->dev);
108
109         ZFCP_LOG_DEBUG("Removing adapter %s\n",
110                        zfcp_get_busid_by_adapter(adapter));
111         write_lock_irq(&zfcp_data.config_lock);
112         list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
113                 list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
114                         list_move(&unit->list, &port->unit_remove_lh);
115                         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
116                                         &unit->status);
117                 }
118                 list_move(&port->list, &adapter->port_remove_lh);
119                 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
120         }
121         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
122         write_unlock_irq(&zfcp_data.config_lock);
123
124         list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
125                 list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
126                         zfcp_unit_dequeue(unit);
127                 }
128                 zfcp_port_dequeue(port);
129         }
130         zfcp_adapter_wait(adapter);
131         zfcp_adapter_dequeue(adapter);
132
133         up(&zfcp_data.config_sema);
134 }
135
136 /**
137  * zfcp_ccw_set_online - set_online function of zfcp driver
138  * @ccw_device: pointer to belonging ccw device
139  *
140  * This function gets called by the common i/o layer and sets an adapter
141  * into state online. Setting an fcp device online means that it will be
142  * registered with the SCSI stack, that the QDIO queues will be set up
143  * and that the adapter will be opened (asynchronously).
144  */
145 static int
146 zfcp_ccw_set_online(struct ccw_device *ccw_device)
147 {
148         struct zfcp_adapter *adapter;
149         int retval;
150
151         down(&zfcp_data.config_sema);
152         adapter = dev_get_drvdata(&ccw_device->dev);
153
154         retval = zfcp_erp_thread_setup(adapter);
155         if (retval) {
156                 ZFCP_LOG_INFO("error: start of error recovery thread for "
157                               "adapter %s failed\n",
158                               zfcp_get_busid_by_adapter(adapter));
159                 goto out;
160         }
161
162         retval = zfcp_adapter_scsi_register(adapter);
163         if (retval)
164                 goto out_scsi_register;
165
166         /* initialize request counter */
167         BUG_ON(!zfcp_reqlist_isempty(adapter));
168         adapter->req_no = 0;
169
170         zfcp_erp_modify_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING,
171                                        ZFCP_SET);
172         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
173         zfcp_erp_wait(adapter);
174         goto out;
175
176  out_scsi_register:
177         zfcp_erp_thread_kill(adapter);
178  out:
179         up(&zfcp_data.config_sema);
180         return retval;
181 }
182
183 /**
184  * zfcp_ccw_set_offline - set_offline function of zfcp driver
185  * @ccw_device: pointer to belonging ccw device
186  *
187  * This function gets called by the common i/o layer and sets an adapter
188  * into state offline.
189  */
190 static int
191 zfcp_ccw_set_offline(struct ccw_device *ccw_device)
192 {
193         struct zfcp_adapter *adapter;
194
195         down(&zfcp_data.config_sema);
196         adapter = dev_get_drvdata(&ccw_device->dev);
197         zfcp_erp_adapter_shutdown(adapter, 0);
198         zfcp_erp_wait(adapter);
199         zfcp_erp_thread_kill(adapter);
200         up(&zfcp_data.config_sema);
201         return 0;
202 }
203
204 /**
205  * zfcp_ccw_notify
206  * @ccw_device: pointer to belonging ccw device
207  * @event: indicates if adapter was detached or attached
208  *
209  * This function gets called by the common i/o layer if an adapter has gone
210  * or reappeared.
211  */
212 static int
213 zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
214 {
215         struct zfcp_adapter *adapter;
216
217         down(&zfcp_data.config_sema);
218         adapter = dev_get_drvdata(&ccw_device->dev);
219         switch (event) {
220         case CIO_GONE:
221                 ZFCP_LOG_NORMAL("adapter %s: device gone\n",
222                                 zfcp_get_busid_by_adapter(adapter));
223                 debug_text_event(adapter->erp_dbf,1,"dev_gone");
224                 zfcp_erp_adapter_shutdown(adapter, 0);
225                 break;
226         case CIO_NO_PATH:
227                 ZFCP_LOG_NORMAL("adapter %s: no path\n",
228                                 zfcp_get_busid_by_adapter(adapter));
229                 debug_text_event(adapter->erp_dbf,1,"no_path");
230                 zfcp_erp_adapter_shutdown(adapter, 0);
231                 break;
232         case CIO_OPER:
233                 ZFCP_LOG_NORMAL("adapter %s: operational again\n",
234                                 zfcp_get_busid_by_adapter(adapter));
235                 debug_text_event(adapter->erp_dbf,1,"dev_oper");
236                 zfcp_erp_modify_adapter_status(adapter,
237                                                ZFCP_STATUS_COMMON_RUNNING,
238                                                ZFCP_SET);
239                 zfcp_erp_adapter_reopen(adapter,
240                                         ZFCP_STATUS_COMMON_ERP_FAILED);
241                 break;
242         }
243         zfcp_erp_wait(adapter);
244         up(&zfcp_data.config_sema);
245         return 1;
246 }
247
248 /**
249  * zfcp_ccw_register - ccw register function
250  *
251  * Registers the driver at the common i/o layer. This function will be called
252  * at module load time/system start.
253  */
254 int __init
255 zfcp_ccw_register(void)
256 {
257         return ccw_driver_register(&zfcp_ccw_driver);
258 }
259
260 /**
261  * zfcp_ccw_shutdown - gets called on reboot/shutdown
262  *
263  * Makes sure that QDIO queues are down when the system gets stopped.
264  */
265 static void
266 zfcp_ccw_shutdown(struct ccw_device *cdev)
267 {
268         struct zfcp_adapter *adapter;
269
270         down(&zfcp_data.config_sema);
271         adapter = dev_get_drvdata(&cdev->dev);
272         zfcp_erp_adapter_shutdown(adapter, 0);
273         zfcp_erp_wait(adapter);
274         up(&zfcp_data.config_sema);
275 }
276
277 #undef ZFCP_LOG_AREA